Add list person visit count API.

CHANGELOG

@@ -1,3 +1,36 @@
+2020-08-20 Version: 1.36.602
+- Add list person visit count API.
+
+2020-08-20 Version: 1.36.601
+- Added Global Distribute Cache OpenAPIs.
+- Added direct connection OpenAPIs.
+
+2020-08-19 Version: 1.36.600
+- Add DescribeLiveDomainCertificateInfo.
+
+2020-08-19 Version: 1.36.599
+- Generated 2020-08-01 for `SmartHosting`.
+
+2020-08-18 Version: 1.36.598
+- Support for describe hbaseue multi-zone model.
+
+2020-08-18 Version: 1.36.597
+- Support session query operations.
+
+2020-08-18 Version: 1.36.596
+- Public beta version.
+- Add Api Overseas.
+
+2020-08-17 Version: 1.36.595
+- Add list event algorithm details.
+
+2020-08-17 Version: 1.36.594
+- Add list event algorithm details.
+
+2020-08-17 Version: 1.36.593
+- Add GetTrace api.
+- Edit Aler api.
+
 2020-08-17 Version: 1.36.592
 - Add pipeline status api.
 

VERSION

@@ -1 +1 @@
-1.36.592
+1.36.602

aliyuncvc/CMakeLists.txt

@@ -31,6 +31,8 @@ set(aliyuncvc_public_header_model
 	include/alibabacloud/aliyuncvc/model/BatchDeleteDevicesResult.h
 	include/alibabacloud/aliyuncvc/model/CallDeviceRequest.h
 	include/alibabacloud/aliyuncvc/model/CallDeviceResult.h
+	include/alibabacloud/aliyuncvc/model/ConferenceToLiveRequest.h
+	include/alibabacloud/aliyuncvc/model/ConferenceToLiveResult.h
 	include/alibabacloud/aliyuncvc/model/CreateDeviceMeetingRequest.h
 	include/alibabacloud/aliyuncvc/model/CreateDeviceMeetingResult.h
 	include/alibabacloud/aliyuncvc/model/CreateEvaluationRequest.h
@@ -47,6 +49,8 @@ set(aliyuncvc_public_header_model
 	include/alibabacloud/aliyuncvc/model/CreateUserInternationalResult.h
 	include/alibabacloud/aliyuncvc/model/CustomGonggeLayoutRequest.h
 	include/alibabacloud/aliyuncvc/model/CustomGonggeLayoutResult.h
+	include/alibabacloud/aliyuncvc/model/CustomLayoutRequest.h
+	include/alibabacloud/aliyuncvc/model/CustomLayoutResult.h
 	include/alibabacloud/aliyuncvc/model/DeleteDeviceRequest.h
 	include/alibabacloud/aliyuncvc/model/DeleteDeviceResult.h
 	include/alibabacloud/aliyuncvc/model/DeleteLiveRequest.h
@@ -55,6 +59,8 @@ set(aliyuncvc_public_header_model
 	include/alibabacloud/aliyuncvc/model/DeleteMeetingResult.h
 	include/alibabacloud/aliyuncvc/model/DeleteUserRequest.h
 	include/alibabacloud/aliyuncvc/model/DeleteUserResult.h
+	include/alibabacloud/aliyuncvc/model/EnableLiveSpeakerRequest.h
+	include/alibabacloud/aliyuncvc/model/EnableLiveSpeakerResult.h
 	include/alibabacloud/aliyuncvc/model/EndDeviceMeetingRequest.h
 	include/alibabacloud/aliyuncvc/model/EndDeviceMeetingResult.h
 	include/alibabacloud/aliyuncvc/model/EndLiveRequest.h
@@ -103,6 +109,8 @@ set(aliyuncvc_public_header_model
 	include/alibabacloud/aliyuncvc/model/RegisterDeviceResult.h
 	include/alibabacloud/aliyuncvc/model/RegisterUemDeviceRequest.h
 	include/alibabacloud/aliyuncvc/model/RegisterUemDeviceResult.h
+	include/alibabacloud/aliyuncvc/model/SendMeetingCommandRequest.h
+	include/alibabacloud/aliyuncvc/model/SendMeetingCommandResult.h
 	include/alibabacloud/aliyuncvc/model/StartLiveRequest.h
 	include/alibabacloud/aliyuncvc/model/StartLiveResult.h
 	include/alibabacloud/aliyuncvc/model/UpdateDeviceHeartBeatRequest.h
@@ -124,6 +132,8 @@ set(aliyuncvc_src
 	src/model/BatchDeleteDevicesResult.cc
 	src/model/CallDeviceRequest.cc
 	src/model/CallDeviceResult.cc
+	src/model/ConferenceToLiveRequest.cc
+	src/model/ConferenceToLiveResult.cc
 	src/model/CreateDeviceMeetingRequest.cc
 	src/model/CreateDeviceMeetingResult.cc
 	src/model/CreateEvaluationRequest.cc
@@ -140,6 +150,8 @@ set(aliyuncvc_src
 	src/model/CreateUserInternationalResult.cc
 	src/model/CustomGonggeLayoutRequest.cc
 	src/model/CustomGonggeLayoutResult.cc
+	src/model/CustomLayoutRequest.cc
+	src/model/CustomLayoutResult.cc
 	src/model/DeleteDeviceRequest.cc
 	src/model/DeleteDeviceResult.cc
 	src/model/DeleteLiveRequest.cc
@@ -148,6 +160,8 @@ set(aliyuncvc_src
 	src/model/DeleteMeetingResult.cc
 	src/model/DeleteUserRequest.cc
 	src/model/DeleteUserResult.cc
+	src/model/EnableLiveSpeakerRequest.cc
+	src/model/EnableLiveSpeakerResult.cc
 	src/model/EndDeviceMeetingRequest.cc
 	src/model/EndDeviceMeetingResult.cc
 	src/model/EndLiveRequest.cc
@@ -196,6 +210,8 @@ set(aliyuncvc_src
 	src/model/RegisterDeviceResult.cc
 	src/model/RegisterUemDeviceRequest.cc
 	src/model/RegisterUemDeviceResult.cc
+	src/model/SendMeetingCommandRequest.cc
+	src/model/SendMeetingCommandResult.cc
 	src/model/StartLiveRequest.cc
 	src/model/StartLiveResult.cc
 	src/model/UpdateDeviceHeartBeatRequest.cc

aliyuncvc/include/alibabacloud/aliyuncvc/AliyuncvcClient.h

@@ -32,6 +32,8 @@
 #include "model/BatchDeleteDevicesResult.h"
 #include "model/CallDeviceRequest.h"
 #include "model/CallDeviceResult.h"
+#include "model/ConferenceToLiveRequest.h"
+#include "model/ConferenceToLiveResult.h"
 #include "model/CreateDeviceMeetingRequest.h"
 #include "model/CreateDeviceMeetingResult.h"
 #include "model/CreateEvaluationRequest.h"
@@ -48,6 +50,8 @@
 #include "model/CreateUserInternationalResult.h"
 #include "model/CustomGonggeLayoutRequest.h"
 #include "model/CustomGonggeLayoutResult.h"
+#include "model/CustomLayoutRequest.h"
+#include "model/CustomLayoutResult.h"
 #include "model/DeleteDeviceRequest.h"
 #include "model/DeleteDeviceResult.h"
 #include "model/DeleteLiveRequest.h"
@@ -56,6 +60,8 @@
 #include "model/DeleteMeetingResult.h"
 #include "model/DeleteUserRequest.h"
 #include "model/DeleteUserResult.h"
+#include "model/EnableLiveSpeakerRequest.h"
+#include "model/EnableLiveSpeakerResult.h"
 #include "model/EndDeviceMeetingRequest.h"
 #include "model/EndDeviceMeetingResult.h"
 #include "model/EndLiveRequest.h"
@@ -104,6 +110,8 @@
 #include "model/RegisterDeviceResult.h"
 #include "model/RegisterUemDeviceRequest.h"
 #include "model/RegisterUemDeviceResult.h"
+#include "model/SendMeetingCommandRequest.h"
+#include "model/SendMeetingCommandResult.h"
 #include "model/StartLiveRequest.h"
 #include "model/StartLiveResult.h"
 #include "model/UpdateDeviceHeartBeatRequest.h"
@@ -136,6 +144,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CallDeviceResult> CallDeviceOutcome;
 			typedef std::future<CallDeviceOutcome> CallDeviceOutcomeCallable;
 			typedef std::function<void(const AliyuncvcClient*, const Model::CallDeviceRequest&, const CallDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CallDeviceAsyncHandler;
+			typedef Outcome<Error, Model::ConferenceToLiveResult> ConferenceToLiveOutcome;
+			typedef std::future<ConferenceToLiveOutcome> ConferenceToLiveOutcomeCallable;
+			typedef std::function<void(const AliyuncvcClient*, const Model::ConferenceToLiveRequest&, const ConferenceToLiveOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConferenceToLiveAsyncHandler;
 			typedef Outcome<Error, Model::CreateDeviceMeetingResult> CreateDeviceMeetingOutcome;
 			typedef std::future<CreateDeviceMeetingOutcome> CreateDeviceMeetingOutcomeCallable;
 			typedef std::function<void(const AliyuncvcClient*, const Model::CreateDeviceMeetingRequest&, const CreateDeviceMeetingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDeviceMeetingAsyncHandler;
@@ -160,6 +171,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CustomGonggeLayoutResult> CustomGonggeLayoutOutcome;
 			typedef std::future<CustomGonggeLayoutOutcome> CustomGonggeLayoutOutcomeCallable;
 			typedef std::function<void(const AliyuncvcClient*, const Model::CustomGonggeLayoutRequest&, const CustomGonggeLayoutOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CustomGonggeLayoutAsyncHandler;
+			typedef Outcome<Error, Model::CustomLayoutResult> CustomLayoutOutcome;
+			typedef std::future<CustomLayoutOutcome> CustomLayoutOutcomeCallable;
+			typedef std::function<void(const AliyuncvcClient*, const Model::CustomLayoutRequest&, const CustomLayoutOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CustomLayoutAsyncHandler;
 			typedef Outcome<Error, Model::DeleteDeviceResult> DeleteDeviceOutcome;
 			typedef std::future<DeleteDeviceOutcome> DeleteDeviceOutcomeCallable;
 			typedef std::function<void(const AliyuncvcClient*, const Model::DeleteDeviceRequest&, const DeleteDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDeviceAsyncHandler;
@@ -172,6 +186,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteUserResult> DeleteUserOutcome;
 			typedef std::future<DeleteUserOutcome> DeleteUserOutcomeCallable;
 			typedef std::function<void(const AliyuncvcClient*, const Model::DeleteUserRequest&, const DeleteUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUserAsyncHandler;
+			typedef Outcome<Error, Model::EnableLiveSpeakerResult> EnableLiveSpeakerOutcome;
+			typedef std::future<EnableLiveSpeakerOutcome> EnableLiveSpeakerOutcomeCallable;
+			typedef std::function<void(const AliyuncvcClient*, const Model::EnableLiveSpeakerRequest&, const EnableLiveSpeakerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableLiveSpeakerAsyncHandler;
 			typedef Outcome<Error, Model::EndDeviceMeetingResult> EndDeviceMeetingOutcome;
 			typedef std::future<EndDeviceMeetingOutcome> EndDeviceMeetingOutcomeCallable;
 			typedef std::function<void(const AliyuncvcClient*, const Model::EndDeviceMeetingRequest&, const EndDeviceMeetingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EndDeviceMeetingAsyncHandler;
@@ -244,6 +261,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RegisterUemDeviceResult> RegisterUemDeviceOutcome;
 			typedef std::future<RegisterUemDeviceOutcome> RegisterUemDeviceOutcomeCallable;
 			typedef std::function<void(const AliyuncvcClient*, const Model::RegisterUemDeviceRequest&, const RegisterUemDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RegisterUemDeviceAsyncHandler;
+			typedef Outcome<Error, Model::SendMeetingCommandResult> SendMeetingCommandOutcome;
+			typedef std::future<SendMeetingCommandOutcome> SendMeetingCommandOutcomeCallable;
+			typedef std::function<void(const AliyuncvcClient*, const Model::SendMeetingCommandRequest&, const SendMeetingCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendMeetingCommandAsyncHandler;
 			typedef Outcome<Error, Model::StartLiveResult> StartLiveOutcome;
 			typedef std::future<StartLiveOutcome> StartLiveOutcomeCallable;
 			typedef std::function<void(const AliyuncvcClient*, const Model::StartLiveRequest&, const StartLiveOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartLiveAsyncHandler;
@@ -276,6 +296,9 @@ namespace AlibabaCloud
 			CallDeviceOutcome callDevice(const Model::CallDeviceRequest &request)const;
 			void callDeviceAsync(const Model::CallDeviceRequest& request, const CallDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CallDeviceOutcomeCallable callDeviceCallable(const Model::CallDeviceRequest& request) const;
+			ConferenceToLiveOutcome conferenceToLive(const Model::ConferenceToLiveRequest &request)const;
+			void conferenceToLiveAsync(const Model::ConferenceToLiveRequest& request, const ConferenceToLiveAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ConferenceToLiveOutcomeCallable conferenceToLiveCallable(const Model::ConferenceToLiveRequest& request) const;
 			CreateDeviceMeetingOutcome createDeviceMeeting(const Model::CreateDeviceMeetingRequest &request)const;
 			void createDeviceMeetingAsync(const Model::CreateDeviceMeetingRequest& request, const CreateDeviceMeetingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDeviceMeetingOutcomeCallable createDeviceMeetingCallable(const Model::CreateDeviceMeetingRequest& request) const;
@@ -300,6 +323,9 @@ namespace AlibabaCloud
 			CustomGonggeLayoutOutcome customGonggeLayout(const Model::CustomGonggeLayoutRequest &request)const;
 			void customGonggeLayoutAsync(const Model::CustomGonggeLayoutRequest& request, const CustomGonggeLayoutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CustomGonggeLayoutOutcomeCallable customGonggeLayoutCallable(const Model::CustomGonggeLayoutRequest& request) const;
+			CustomLayoutOutcome customLayout(const Model::CustomLayoutRequest &request)const;
+			void customLayoutAsync(const Model::CustomLayoutRequest& request, const CustomLayoutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CustomLayoutOutcomeCallable customLayoutCallable(const Model::CustomLayoutRequest& request) const;
 			DeleteDeviceOutcome deleteDevice(const Model::DeleteDeviceRequest &request)const;
 			void deleteDeviceAsync(const Model::DeleteDeviceRequest& request, const DeleteDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDeviceOutcomeCallable deleteDeviceCallable(const Model::DeleteDeviceRequest& request) const;
@@ -312,6 +338,9 @@ namespace AlibabaCloud
 			DeleteUserOutcome deleteUser(const Model::DeleteUserRequest &request)const;
 			void deleteUserAsync(const Model::DeleteUserRequest& request, const DeleteUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteUserOutcomeCallable deleteUserCallable(const Model::DeleteUserRequest& request) const;
+			EnableLiveSpeakerOutcome enableLiveSpeaker(const Model::EnableLiveSpeakerRequest &request)const;
+			void enableLiveSpeakerAsync(const Model::EnableLiveSpeakerRequest& request, const EnableLiveSpeakerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableLiveSpeakerOutcomeCallable enableLiveSpeakerCallable(const Model::EnableLiveSpeakerRequest& request) const;
 			EndDeviceMeetingOutcome endDeviceMeeting(const Model::EndDeviceMeetingRequest &request)const;
 			void endDeviceMeetingAsync(const Model::EndDeviceMeetingRequest& request, const EndDeviceMeetingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EndDeviceMeetingOutcomeCallable endDeviceMeetingCallable(const Model::EndDeviceMeetingRequest& request) const;
@@ -384,6 +413,9 @@ namespace AlibabaCloud
 			RegisterUemDeviceOutcome registerUemDevice(const Model::RegisterUemDeviceRequest &request)const;
 			void registerUemDeviceAsync(const Model::RegisterUemDeviceRequest& request, const RegisterUemDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RegisterUemDeviceOutcomeCallable registerUemDeviceCallable(const Model::RegisterUemDeviceRequest& request) const;
+			SendMeetingCommandOutcome sendMeetingCommand(const Model::SendMeetingCommandRequest &request)const;
+			void sendMeetingCommandAsync(const Model::SendMeetingCommandRequest& request, const SendMeetingCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SendMeetingCommandOutcomeCallable sendMeetingCommandCallable(const Model::SendMeetingCommandRequest& request) const;
 			StartLiveOutcome startLive(const Model::StartLiveRequest &request)const;
 			void startLiveAsync(const Model::StartLiveRequest& request, const StartLiveAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartLiveOutcomeCallable startLiveCallable(const Model::StartLiveRequest& request) const;

aliyuncvc/include/alibabacloud/aliyuncvc/model/ConferenceToLiveRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIYUNCVC_MODEL_CONFERENCETOLIVEREQUEST_H_
+#define ALIBABACLOUD_ALIYUNCVC_MODEL_CONFERENCETOLIVEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/aliyuncvc/AliyuncvcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Aliyuncvc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIYUNCVC_EXPORT ConferenceToLiveRequest : public RpcServiceRequest
+			{
+
+			public:
+				ConferenceToLiveRequest();
+				~ConferenceToLiveRequest();
+
+				std::string getUserId()const;
+				void setUserId(const std::string& userId);
+				bool getOpenPasswordFlag()const;
+				void setOpenPasswordFlag(bool openPasswordFlag);
+				std::string getMeetingUUID()const;
+				void setMeetingUUID(const std::string& meetingUUID);
+				std::string getPassword()const;
+				void setPassword(const std::string& password);
+				std::string getLiveName()const;
+				void setLiveName(const std::string& liveName);
+
+            private:
+				std::string userId_;
+				bool openPasswordFlag_;
+				std::string meetingUUID_;
+				std::string password_;
+				std::string liveName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIYUNCVC_MODEL_CONFERENCETOLIVEREQUEST_H_

aliyuncvc/include/alibabacloud/aliyuncvc/model/ConferenceToLiveResult.h

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

aliyuncvc/include/alibabacloud/aliyuncvc/model/CreateLiveRequest.h

@@ -35,8 +35,6 @@ namespace AlibabaCloud
 				CreateLiveRequest();
 				~CreateLiveRequest();
 
-				std::string getMemo()const;
-				void setMemo(const std::string& memo);
 				std::string getUserId()const;
 				void setUserId(const std::string& userId);
 				bool getOpenPasswordFlag()const;
@@ -47,7 +45,6 @@ namespace AlibabaCloud
 				void setLiveName(const std::string& liveName);
 
             private:
-				std::string memo_;
 				std::string userId_;
 				bool openPasswordFlag_;
 				std::string password_;

aliyuncvc/include/alibabacloud/aliyuncvc/model/CustomLayoutRequest.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_ALIYUNCVC_MODEL_CUSTOMLAYOUTREQUEST_H_
+#define ALIBABACLOUD_ALIYUNCVC_MODEL_CUSTOMLAYOUTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/aliyuncvc/AliyuncvcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Aliyuncvc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIYUNCVC_EXPORT CustomLayoutRequest : public RpcServiceRequest
+			{
+
+			public:
+				CustomLayoutRequest();
+				~CustomLayoutRequest();
+
+				std::string getLiveUUID()const;
+				void setLiveUUID(const std::string& liveUUID);
+				std::string getLayoutInfo()const;
+				void setLayoutInfo(const std::string& layoutInfo);
+
+            private:
+				std::string liveUUID_;
+				std::string layoutInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIYUNCVC_MODEL_CUSTOMLAYOUTREQUEST_H_

aliyuncvc/include/alibabacloud/aliyuncvc/model/CustomLayoutResult.h

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

aliyuncvc/include/alibabacloud/aliyuncvc/model/EnableLiveSpeakerRequest.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_ALIYUNCVC_MODEL_ENABLELIVESPEAKERREQUEST_H_
+#define ALIBABACLOUD_ALIYUNCVC_MODEL_ENABLELIVESPEAKERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/aliyuncvc/AliyuncvcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Aliyuncvc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIYUNCVC_EXPORT EnableLiveSpeakerRequest : public RpcServiceRequest
+			{
+
+			public:
+				EnableLiveSpeakerRequest();
+				~EnableLiveSpeakerRequest();
+
+				std::string getLiveUUID()const;
+				void setLiveUUID(const std::string& liveUUID);
+				bool getEnableSpeakerFlag()const;
+				void setEnableSpeakerFlag(bool enableSpeakerFlag);
+
+            private:
+				std::string liveUUID_;
+				bool enableSpeakerFlag_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIYUNCVC_MODEL_ENABLELIVESPEAKERREQUEST_H_

aliyuncvc/include/alibabacloud/aliyuncvc/model/EnableLiveSpeakerResult.h

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

aliyuncvc/include/alibabacloud/aliyuncvc/model/SendMeetingCommandRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ALIYUNCVC_MODEL_SENDMEETINGCOMMANDREQUEST_H_
+#define ALIBABACLOUD_ALIYUNCVC_MODEL_SENDMEETINGCOMMANDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/aliyuncvc/AliyuncvcExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Aliyuncvc
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ALIYUNCVC_EXPORT SendMeetingCommandRequest : public RpcServiceRequest
+			{
+
+			public:
+				SendMeetingCommandRequest();
+				~SendMeetingCommandRequest();
+
+				std::string getOperatorMemberUUID()const;
+				void setOperatorMemberUUID(const std::string& operatorMemberUUID);
+				std::string getMemberUUID()const;
+				void setMemberUUID(const std::string& memberUUID);
+				int getSendType()const;
+				void setSendType(int sendType);
+				std::string getCommand()const;
+				void setCommand(const std::string& command);
+				std::string getMeetingUUID()const;
+				void setMeetingUUID(const std::string& meetingUUID);
+
+            private:
+				std::string operatorMemberUUID_;
+				std::string memberUUID_;
+				int sendType_;
+				std::string command_;
+				std::string meetingUUID_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ALIYUNCVC_MODEL_SENDMEETINGCOMMANDREQUEST_H_

aliyuncvc/include/alibabacloud/aliyuncvc/model/SendMeetingCommandResult.h

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

aliyuncvc/include/alibabacloud/aliyuncvc/model/StartLiveRequest.h

@@ -37,12 +37,18 @@ namespace AlibabaCloud
 
 				std::string getLiveUUID()const;
 				void setLiveUUID(const std::string& liveUUID);
+				std::string getPushInfo()const;
+				void setPushInfo(const std::string& pushInfo);
 				std::string getUserId()const;
 				void setUserId(const std::string& userId);
+				std::string getLayoutInfo()const;
+				void setLayoutInfo(const std::string& layoutInfo);
 
             private:
 				std::string liveUUID_;
+				std::string pushInfo_;
 				std::string userId_;
+				std::string layoutInfo_;
 
 			};
 		}

aliyuncvc/src/AliyuncvcClient.cc

@@ -231,6 +231,42 @@ AliyuncvcClient::CallDeviceOutcomeCallable AliyuncvcClient::callDeviceCallable(c
 	return task->get_future();
 }
 
+AliyuncvcClient::ConferenceToLiveOutcome AliyuncvcClient::conferenceToLive(const ConferenceToLiveRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ConferenceToLiveOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ConferenceToLiveOutcome(ConferenceToLiveResult(outcome.result()));
+	else
+		return ConferenceToLiveOutcome(outcome.error());
+}
+
+void AliyuncvcClient::conferenceToLiveAsync(const ConferenceToLiveRequest& request, const ConferenceToLiveAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, conferenceToLive(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AliyuncvcClient::ConferenceToLiveOutcomeCallable AliyuncvcClient::conferenceToLiveCallable(const ConferenceToLiveRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ConferenceToLiveOutcome()>>(
+			[this, request]()
+			{
+			return this->conferenceToLive(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AliyuncvcClient::CreateDeviceMeetingOutcome AliyuncvcClient::createDeviceMeeting(const CreateDeviceMeetingRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -519,6 +555,42 @@ AliyuncvcClient::CustomGonggeLayoutOutcomeCallable AliyuncvcClient::customGongge
 	return task->get_future();
 }
 
+AliyuncvcClient::CustomLayoutOutcome AliyuncvcClient::customLayout(const CustomLayoutRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CustomLayoutOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CustomLayoutOutcome(CustomLayoutResult(outcome.result()));
+	else
+		return CustomLayoutOutcome(outcome.error());
+}
+
+void AliyuncvcClient::customLayoutAsync(const CustomLayoutRequest& request, const CustomLayoutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, customLayout(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AliyuncvcClient::CustomLayoutOutcomeCallable AliyuncvcClient::customLayoutCallable(const CustomLayoutRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CustomLayoutOutcome()>>(
+			[this, request]()
+			{
+			return this->customLayout(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AliyuncvcClient::DeleteDeviceOutcome AliyuncvcClient::deleteDevice(const DeleteDeviceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -663,6 +735,42 @@ AliyuncvcClient::DeleteUserOutcomeCallable AliyuncvcClient::deleteUserCallable(c
 	return task->get_future();
 }
 
+AliyuncvcClient::EnableLiveSpeakerOutcome AliyuncvcClient::enableLiveSpeaker(const EnableLiveSpeakerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableLiveSpeakerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableLiveSpeakerOutcome(EnableLiveSpeakerResult(outcome.result()));
+	else
+		return EnableLiveSpeakerOutcome(outcome.error());
+}
+
+void AliyuncvcClient::enableLiveSpeakerAsync(const EnableLiveSpeakerRequest& request, const EnableLiveSpeakerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableLiveSpeaker(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AliyuncvcClient::EnableLiveSpeakerOutcomeCallable AliyuncvcClient::enableLiveSpeakerCallable(const EnableLiveSpeakerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableLiveSpeakerOutcome()>>(
+			[this, request]()
+			{
+			return this->enableLiveSpeaker(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AliyuncvcClient::EndDeviceMeetingOutcome AliyuncvcClient::endDeviceMeeting(const EndDeviceMeetingRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1527,6 +1635,42 @@ AliyuncvcClient::RegisterUemDeviceOutcomeCallable AliyuncvcClient::registerUemDe
 	return task->get_future();
 }
 
+AliyuncvcClient::SendMeetingCommandOutcome AliyuncvcClient::sendMeetingCommand(const SendMeetingCommandRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SendMeetingCommandOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SendMeetingCommandOutcome(SendMeetingCommandResult(outcome.result()));
+	else
+		return SendMeetingCommandOutcome(outcome.error());
+}
+
+void AliyuncvcClient::sendMeetingCommandAsync(const SendMeetingCommandRequest& request, const SendMeetingCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, sendMeetingCommand(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AliyuncvcClient::SendMeetingCommandOutcomeCallable AliyuncvcClient::sendMeetingCommandCallable(const SendMeetingCommandRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SendMeetingCommandOutcome()>>(
+			[this, request]()
+			{
+			return this->sendMeetingCommand(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AliyuncvcClient::StartLiveOutcome AliyuncvcClient::startLive(const StartLiveRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

aliyuncvc/src/model/ConferenceToLiveRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/aliyuncvc/model/ConferenceToLiveRequest.h>
+
+using AlibabaCloud::Aliyuncvc::Model::ConferenceToLiveRequest;
+
+ConferenceToLiveRequest::ConferenceToLiveRequest() :
+	RpcServiceRequest("aliyuncvc", "2019-10-30", "ConferenceToLive")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ConferenceToLiveRequest::~ConferenceToLiveRequest()
+{}
+
+std::string ConferenceToLiveRequest::getUserId()const
+{
+	return userId_;
+}
+
+void ConferenceToLiveRequest::setUserId(const std::string& userId)
+{
+	userId_ = userId;
+	setBodyParameter("UserId", userId);
+}
+
+bool ConferenceToLiveRequest::getOpenPasswordFlag()const
+{
+	return openPasswordFlag_;
+}
+
+void ConferenceToLiveRequest::setOpenPasswordFlag(bool openPasswordFlag)
+{
+	openPasswordFlag_ = openPasswordFlag;
+	setBodyParameter("OpenPasswordFlag", openPasswordFlag ? "true" : "false");
+}
+
+std::string ConferenceToLiveRequest::getMeetingUUID()const
+{
+	return meetingUUID_;
+}
+
+void ConferenceToLiveRequest::setMeetingUUID(const std::string& meetingUUID)
+{
+	meetingUUID_ = meetingUUID;
+	setBodyParameter("MeetingUUID", meetingUUID);
+}
+
+std::string ConferenceToLiveRequest::getPassword()const
+{
+	return password_;
+}
+
+void ConferenceToLiveRequest::setPassword(const std::string& password)
+{
+	password_ = password;
+	setBodyParameter("Password", password);
+}
+
+std::string ConferenceToLiveRequest::getLiveName()const
+{
+	return liveName_;
+}
+
+void ConferenceToLiveRequest::setLiveName(const std::string& liveName)
+{
+	liveName_ = liveName;
+	setBodyParameter("LiveName", liveName);
+}
+

aliyuncvc/src/model/ConferenceToLiveResult.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/aliyuncvc/model/ConferenceToLiveResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Aliyuncvc;
+using namespace AlibabaCloud::Aliyuncvc::Model;
+
+ConferenceToLiveResult::ConferenceToLiveResult() :
+	ServiceResult()
+{}
+
+ConferenceToLiveResult::ConferenceToLiveResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ConferenceToLiveResult::~ConferenceToLiveResult()
+{}
+
+void ConferenceToLiveResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto liveInfoNode = value["LiveInfo"];
+	if(!liveInfoNode["LiveUUID"].isNull())
+		liveInfo_.liveUUID = liveInfoNode["LiveUUID"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = std::stoi(value["ErrorCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string ConferenceToLiveResult::getMessage()const
+{
+	return message_;
+}
+
+int ConferenceToLiveResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+bool ConferenceToLiveResult::getSuccess()const
+{
+	return success_;
+}
+
+ConferenceToLiveResult::LiveInfo ConferenceToLiveResult::getLiveInfo()const
+{
+	return liveInfo_;
+}
+

aliyuncvc/src/model/CreateLiveRequest.cc

@@ -27,17 +27,6 @@ CreateLiveRequest::CreateLiveRequest() :
 CreateLiveRequest::~CreateLiveRequest()
 {}
 
-std::string CreateLiveRequest::getMemo()const
-{
-	return memo_;
-}
-
-void CreateLiveRequest::setMemo(const std::string& memo)
-{
-	memo_ = memo;
-	setBodyParameter("Memo", memo);
-}
-
 std::string CreateLiveRequest::getUserId()const
 {
 	return userId_;

aliyuncvc/src/model/CustomLayoutRequest.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/aliyuncvc/model/CustomLayoutRequest.h>
+
+using AlibabaCloud::Aliyuncvc::Model::CustomLayoutRequest;
+
+CustomLayoutRequest::CustomLayoutRequest() :
+	RpcServiceRequest("aliyuncvc", "2019-10-30", "CustomLayout")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CustomLayoutRequest::~CustomLayoutRequest()
+{}
+
+std::string CustomLayoutRequest::getLiveUUID()const
+{
+	return liveUUID_;
+}
+
+void CustomLayoutRequest::setLiveUUID(const std::string& liveUUID)
+{
+	liveUUID_ = liveUUID;
+	setBodyParameter("LiveUUID", liveUUID);
+}
+
+std::string CustomLayoutRequest::getLayoutInfo()const
+{
+	return layoutInfo_;
+}
+
+void CustomLayoutRequest::setLayoutInfo(const std::string& layoutInfo)
+{
+	layoutInfo_ = layoutInfo;
+	setBodyParameter("LayoutInfo", layoutInfo);
+}
+

aliyuncvc/src/model/CustomLayoutResult.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/aliyuncvc/model/CustomLayoutResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Aliyuncvc;
+using namespace AlibabaCloud::Aliyuncvc::Model;
+
+CustomLayoutResult::CustomLayoutResult() :
+	ServiceResult()
+{}
+
+CustomLayoutResult::CustomLayoutResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CustomLayoutResult::~CustomLayoutResult()
+{}
+
+void CustomLayoutResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = std::stoi(value["ErrorCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string CustomLayoutResult::getMessage()const
+{
+	return message_;
+}
+
+int CustomLayoutResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+bool CustomLayoutResult::getSuccess()const
+{
+	return success_;
+}
+

aliyuncvc/src/model/EnableLiveSpeakerRequest.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/aliyuncvc/model/EnableLiveSpeakerRequest.h>
+
+using AlibabaCloud::Aliyuncvc::Model::EnableLiveSpeakerRequest;
+
+EnableLiveSpeakerRequest::EnableLiveSpeakerRequest() :
+	RpcServiceRequest("aliyuncvc", "2019-10-30", "EnableLiveSpeaker")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+EnableLiveSpeakerRequest::~EnableLiveSpeakerRequest()
+{}
+
+std::string EnableLiveSpeakerRequest::getLiveUUID()const
+{
+	return liveUUID_;
+}
+
+void EnableLiveSpeakerRequest::setLiveUUID(const std::string& liveUUID)
+{
+	liveUUID_ = liveUUID;
+	setBodyParameter("LiveUUID", liveUUID);
+}
+
+bool EnableLiveSpeakerRequest::getEnableSpeakerFlag()const
+{
+	return enableSpeakerFlag_;
+}
+
+void EnableLiveSpeakerRequest::setEnableSpeakerFlag(bool enableSpeakerFlag)
+{
+	enableSpeakerFlag_ = enableSpeakerFlag;
+	setBodyParameter("EnableSpeakerFlag", enableSpeakerFlag ? "true" : "false");
+}
+

aliyuncvc/src/model/EnableLiveSpeakerResult.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/aliyuncvc/model/EnableLiveSpeakerResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Aliyuncvc;
+using namespace AlibabaCloud::Aliyuncvc::Model;
+
+EnableLiveSpeakerResult::EnableLiveSpeakerResult() :
+	ServiceResult()
+{}
+
+EnableLiveSpeakerResult::EnableLiveSpeakerResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+EnableLiveSpeakerResult::~EnableLiveSpeakerResult()
+{}
+
+void EnableLiveSpeakerResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = std::stoi(value["ErrorCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string EnableLiveSpeakerResult::getMessage()const
+{
+	return message_;
+}
+
+int EnableLiveSpeakerResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+bool EnableLiveSpeakerResult::getSuccess()const
+{
+	return success_;
+}
+

aliyuncvc/src/model/SendMeetingCommandRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/aliyuncvc/model/SendMeetingCommandRequest.h>
+
+using AlibabaCloud::Aliyuncvc::Model::SendMeetingCommandRequest;
+
+SendMeetingCommandRequest::SendMeetingCommandRequest() :
+	RpcServiceRequest("aliyuncvc", "2019-10-30", "SendMeetingCommand")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SendMeetingCommandRequest::~SendMeetingCommandRequest()
+{}
+
+std::string SendMeetingCommandRequest::getOperatorMemberUUID()const
+{
+	return operatorMemberUUID_;
+}
+
+void SendMeetingCommandRequest::setOperatorMemberUUID(const std::string& operatorMemberUUID)
+{
+	operatorMemberUUID_ = operatorMemberUUID;
+	setBodyParameter("OperatorMemberUUID", operatorMemberUUID);
+}
+
+std::string SendMeetingCommandRequest::getMemberUUID()const
+{
+	return memberUUID_;
+}
+
+void SendMeetingCommandRequest::setMemberUUID(const std::string& memberUUID)
+{
+	memberUUID_ = memberUUID;
+	setParameter("MemberUUID", memberUUID);
+}
+
+int SendMeetingCommandRequest::getSendType()const
+{
+	return sendType_;
+}
+
+void SendMeetingCommandRequest::setSendType(int sendType)
+{
+	sendType_ = sendType;
+	setBodyParameter("SendType", std::to_string(sendType));
+}
+
+std::string SendMeetingCommandRequest::getCommand()const
+{
+	return command_;
+}
+
+void SendMeetingCommandRequest::setCommand(const std::string& command)
+{
+	command_ = command;
+	setBodyParameter("Command", command);
+}
+
+std::string SendMeetingCommandRequest::getMeetingUUID()const
+{
+	return meetingUUID_;
+}
+
+void SendMeetingCommandRequest::setMeetingUUID(const std::string& meetingUUID)
+{
+	meetingUUID_ = meetingUUID;
+	setParameter("MeetingUUID", meetingUUID);
+}
+

aliyuncvc/src/model/SendMeetingCommandResult.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/aliyuncvc/model/SendMeetingCommandResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Aliyuncvc;
+using namespace AlibabaCloud::Aliyuncvc::Model;
+
+SendMeetingCommandResult::SendMeetingCommandResult() :
+	ServiceResult()
+{}
+
+SendMeetingCommandResult::SendMeetingCommandResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SendMeetingCommandResult::~SendMeetingCommandResult()
+{}
+
+void SendMeetingCommandResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = std::stoi(value["ErrorCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string SendMeetingCommandResult::getMessage()const
+{
+	return message_;
+}
+
+int SendMeetingCommandResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+bool SendMeetingCommandResult::getSuccess()const
+{
+	return success_;
+}
+

aliyuncvc/src/model/StartLiveRequest.cc

@@ -38,6 +38,17 @@ void StartLiveRequest::setLiveUUID(const std::string& liveUUID)
 	setBodyParameter("LiveUUID", liveUUID);
 }
 
+std::string StartLiveRequest::getPushInfo()const
+{
+	return pushInfo_;
+}
+
+void StartLiveRequest::setPushInfo(const std::string& pushInfo)
+{
+	pushInfo_ = pushInfo;
+	setBodyParameter("PushInfo", pushInfo);
+}
+
 std::string StartLiveRequest::getUserId()const
 {
 	return userId_;
@@ -49,3 +60,14 @@ void StartLiveRequest::setUserId(const std::string& userId)
 	setBodyParameter("UserId", userId);
 }
 
+std::string StartLiveRequest::getLayoutInfo()const
+{
+	return layoutInfo_;
+}
+
+void StartLiveRequest::setLayoutInfo(const std::string& layoutInfo)
+{
+	layoutInfo_ = layoutInfo;
+	setBodyParameter("LayoutInfo", layoutInfo);
+}
+

arms/CMakeLists.txt

@@ -63,6 +63,8 @@ set(arms_public_header_model
 	include/alibabacloud/arms/model/GetStackResult.h
 	include/alibabacloud/arms/model/GetTraceRequest.h
 	include/alibabacloud/arms/model/GetTraceResult.h
+	include/alibabacloud/arms/model/GetTraceAppRequest.h
+	include/alibabacloud/arms/model/GetTraceAppResult.h
 	include/alibabacloud/arms/model/ImportAppAlertRulesRequest.h
 	include/alibabacloud/arms/model/ImportAppAlertRulesResult.h
 	include/alibabacloud/arms/model/ImportCustomAlertRulesRequest.h
@@ -158,6 +160,8 @@ set(arms_src
 	src/model/GetStackResult.cc
 	src/model/GetTraceRequest.cc
 	src/model/GetTraceResult.cc
+	src/model/GetTraceAppRequest.cc
+	src/model/GetTraceAppResult.cc
 	src/model/ImportAppAlertRulesRequest.cc
 	src/model/ImportAppAlertRulesResult.cc
 	src/model/ImportCustomAlertRulesRequest.cc

arms/include/alibabacloud/arms/ARMSClient.h

@@ -64,6 +64,8 @@
 #include "model/GetStackResult.h"
 #include "model/GetTraceRequest.h"
 #include "model/GetTraceResult.h"
+#include "model/GetTraceAppRequest.h"
+#include "model/GetTraceAppResult.h"
 #include "model/ImportAppAlertRulesRequest.h"
 #include "model/ImportAppAlertRulesResult.h"
 #include "model/ImportCustomAlertRulesRequest.h"
@@ -186,6 +188,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetTraceResult> GetTraceOutcome;
 			typedef std::future<GetTraceOutcome> GetTraceOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::GetTraceRequest&, const GetTraceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTraceAsyncHandler;
+			typedef Outcome<Error, Model::GetTraceAppResult> GetTraceAppOutcome;
+			typedef std::future<GetTraceAppOutcome> GetTraceAppOutcomeCallable;
+			typedef std::function<void(const ARMSClient*, const Model::GetTraceAppRequest&, const GetTraceAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTraceAppAsyncHandler;
 			typedef Outcome<Error, Model::ImportAppAlertRulesResult> ImportAppAlertRulesOutcome;
 			typedef std::future<ImportAppAlertRulesOutcome> ImportAppAlertRulesOutcomeCallable;
 			typedef std::function<void(const ARMSClient*, const Model::ImportAppAlertRulesRequest&, const ImportAppAlertRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImportAppAlertRulesAsyncHandler;
@@ -329,6 +334,9 @@ namespace AlibabaCloud
 			GetTraceOutcome getTrace(const Model::GetTraceRequest &request)const;
 			void getTraceAsync(const Model::GetTraceRequest& request, const GetTraceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetTraceOutcomeCallable getTraceCallable(const Model::GetTraceRequest& request) const;
+			GetTraceAppOutcome getTraceApp(const Model::GetTraceAppRequest &request)const;
+			void getTraceAppAsync(const Model::GetTraceAppRequest& request, const GetTraceAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTraceAppOutcomeCallable getTraceAppCallable(const Model::GetTraceAppRequest& request) const;
 			ImportAppAlertRulesOutcome importAppAlertRules(const Model::ImportAppAlertRulesRequest &request)const;
 			void importAppAlertRulesAsync(const Model::ImportAppAlertRulesRequest& request, const ImportAppAlertRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ImportAppAlertRulesOutcomeCallable importAppAlertRulesCallable(const Model::ImportAppAlertRulesRequest& request) const;

arms/include/alibabacloud/arms/model/GetTraceAppRequest.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_ARMS_MODEL_GETTRACEAPPREQUEST_H_
+#define ALIBABACLOUD_ARMS_MODEL_GETTRACEAPPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT GetTraceAppRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetTraceAppRequest();
+				~GetTraceAppRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getPid()const;
+				void setPid(const std::string& pid);
+
+            private:
+				std::string regionId_;
+				std::string pid_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_GETTRACEAPPREQUEST_H_

arms/include/alibabacloud/arms/model/GetTraceAppResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ARMS_MODEL_GETTRACEAPPRESULT_H_
+#define ALIBABACLOUD_ARMS_MODEL_GETTRACEAPPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/arms/ARMSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ARMS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ARMS_EXPORT GetTraceAppResult : public ServiceResult
+			{
+			public:
+				struct TraceApp
+				{
+					std::string type;
+					long appId;
+					std::string userId;
+					long createTime;
+					long updateTime;
+					std::string pid;
+					bool show;
+					std::vector<std::string> labels;
+					std::string regionId;
+					std::string appName;
+				};
+
+
+				GetTraceAppResult();
+				explicit GetTraceAppResult(const std::string &payload);
+				~GetTraceAppResult();
+				TraceApp getTraceApp()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				TraceApp traceApp_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ARMS_MODEL_GETTRACEAPPRESULT_H_

arms/include/alibabacloud/arms/model/ImportCustomAlertRulesRequest.h

@@ -37,21 +37,24 @@ namespace AlibabaCloud
 
 				bool getIsAutoStart()const;
 				void setIsAutoStart(bool isAutoStart);
+				std::string getProxyUserId()const;
+				void setProxyUserId(const std::string& proxyUserId);
 				std::string getRegionId()const;
 				void setRegionId(const std::string& regionId);
 				std::string getContactGroupIds()const;
 				void setContactGroupIds(const std::string& contactGroupIds);
 				std::string getTemplateAlertConfig()const;
 				void setTemplateAlertConfig(const std::string& templateAlertConfig);
-				std::string getProxyUserId()const;
-				void setProxyUserId(const std::string& proxyUserId);
+				std::string getTemplageAlertConfig()const;
+				void setTemplageAlertConfig(const std::string& templageAlertConfig);
 
             private:
 				bool isAutoStart_;
+				std::string proxyUserId_;
 				std::string regionId_;
 				std::string contactGroupIds_;
 				std::string templateAlertConfig_;
-				std::string proxyUserId_;
+				std::string templageAlertConfig_;
 
 			};
 		}

arms/include/alibabacloud/arms/model/SearchAlertContactGroupResult.h

@@ -34,7 +34,20 @@ namespace AlibabaCloud
 			public:
 				struct ContactGroup
 				{
+					struct Contact
+					{
+						std::string email;
+						std::string phone;
+						std::string userId;
+						long createTime;
+						long updateTime;
+						long contactId;
+						std::string dingRobot;
+						std::string contactName;
+						bool systemNoc;
+					};
 					long contactGroupId;
+					std::vector<ContactGroup::Contact> contacts;
 					std::string contactGroupName;
 					std::string userId;
 					long createTime;

arms/include/alibabacloud/arms/model/SearchEventsResult.h

@@ -37,7 +37,7 @@ namespace AlibabaCloud
 					struct EventItem
 					{
 						int alertType;
-						int eventLevel;
+						std::string eventLevel;
 						long alertId;
 						std::string alertName;
 						std::string message;

arms/src/ARMSClient.cc

@@ -807,6 +807,42 @@ ARMSClient::GetTraceOutcomeCallable ARMSClient::getTraceCallable(const GetTraceR
 	return task->get_future();
 }
 
+ARMSClient::GetTraceAppOutcome ARMSClient::getTraceApp(const GetTraceAppRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetTraceAppOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetTraceAppOutcome(GetTraceAppResult(outcome.result()));
+	else
+		return GetTraceAppOutcome(outcome.error());
+}
+
+void ARMSClient::getTraceAppAsync(const GetTraceAppRequest& request, const GetTraceAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getTraceApp(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ARMSClient::GetTraceAppOutcomeCallable ARMSClient::getTraceAppCallable(const GetTraceAppRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetTraceAppOutcome()>>(
+			[this, request]()
+			{
+			return this->getTraceApp(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ARMSClient::ImportAppAlertRulesOutcome ARMSClient::importAppAlertRules(const ImportAppAlertRulesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

arms/src/model/GetTraceAppRequest.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/arms/model/GetTraceAppRequest.h>
+
+using AlibabaCloud::ARMS::Model::GetTraceAppRequest;
+
+GetTraceAppRequest::GetTraceAppRequest() :
+	RpcServiceRequest("arms", "2019-08-08", "GetTraceApp")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetTraceAppRequest::~GetTraceAppRequest()
+{}
+
+std::string GetTraceAppRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetTraceAppRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string GetTraceAppRequest::getPid()const
+{
+	return pid_;
+}
+
+void GetTraceAppRequest::setPid(const std::string& pid)
+{
+	pid_ = pid;
+	setParameter("Pid", pid);
+}
+

arms/src/model/GetTraceAppResult.cc

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/arms/model/GetTraceAppResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ARMS;
+using namespace AlibabaCloud::ARMS::Model;
+
+GetTraceAppResult::GetTraceAppResult() :
+	ServiceResult()
+{}
+
+GetTraceAppResult::GetTraceAppResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetTraceAppResult::~GetTraceAppResult()
+{}
+
+void GetTraceAppResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto traceAppNode = value["TraceApp"];
+	if(!traceAppNode["AppId"].isNull())
+		traceApp_.appId = std::stol(traceAppNode["AppId"].asString());
+	if(!traceAppNode["Pid"].isNull())
+		traceApp_.pid = traceAppNode["Pid"].asString();
+	if(!traceAppNode["AppName"].isNull())
+		traceApp_.appName = traceAppNode["AppName"].asString();
+	if(!traceAppNode["Type"].isNull())
+		traceApp_.type = traceAppNode["Type"].asString();
+	if(!traceAppNode["UserId"].isNull())
+		traceApp_.userId = traceAppNode["UserId"].asString();
+	if(!traceAppNode["RegionId"].isNull())
+		traceApp_.regionId = traceAppNode["RegionId"].asString();
+	if(!traceAppNode["CreateTime"].isNull())
+		traceApp_.createTime = std::stol(traceAppNode["CreateTime"].asString());
+	if(!traceAppNode["UpdateTime"].isNull())
+		traceApp_.updateTime = std::stol(traceAppNode["UpdateTime"].asString());
+	if(!traceAppNode["Show"].isNull())
+		traceApp_.show = traceAppNode["Show"].asString() == "true";
+		auto allLabels = traceAppNode["Labels"]["Labels"];
+		for (auto value : allLabels)
+			traceApp_.labels.push_back(value.asString());
+
+}
+
+GetTraceAppResult::TraceApp GetTraceAppResult::getTraceApp()const
+{
+	return traceApp_;
+}
+

arms/src/model/ImportCustomAlertRulesRequest.cc

@@ -38,6 +38,17 @@ void ImportCustomAlertRulesRequest::setIsAutoStart(bool isAutoStart)
 	setParameter("IsAutoStart", isAutoStart ? "true" : "false");
 }
 
+std::string ImportCustomAlertRulesRequest::getProxyUserId()const
+{
+	return proxyUserId_;
+}
+
+void ImportCustomAlertRulesRequest::setProxyUserId(const std::string& proxyUserId)
+{
+	proxyUserId_ = proxyUserId;
+	setParameter("ProxyUserId", proxyUserId);
+}
+
 std::string ImportCustomAlertRulesRequest::getRegionId()const
 {
 	return regionId_;
@@ -71,14 +82,14 @@ void ImportCustomAlertRulesRequest::setTemplateAlertConfig(const std::string& te
 	setParameter("TemplateAlertConfig", templateAlertConfig);
 }
 
-std::string ImportCustomAlertRulesRequest::getProxyUserId()const
+std::string ImportCustomAlertRulesRequest::getTemplageAlertConfig()const
 {
-	return proxyUserId_;
+	return templageAlertConfig_;
 }
 
-void ImportCustomAlertRulesRequest::setProxyUserId(const std::string& proxyUserId)
+void ImportCustomAlertRulesRequest::setTemplageAlertConfig(const std::string& templageAlertConfig)
 {
-	proxyUserId_ = proxyUserId;
-	setParameter("ProxyUserId", proxyUserId);
+	templageAlertConfig_ = templageAlertConfig;
+	setParameter("TemplageAlertConfig", templageAlertConfig);
 }
 

arms/src/model/SearchAlertContactGroupResult.cc

@@ -53,6 +53,30 @@ void SearchAlertContactGroupResult::parse(const std::string &payload)
 			contactGroupsObject.createTime = std::stol(valueContactGroupsContactGroup["CreateTime"].asString());
 		if(!valueContactGroupsContactGroup["UpdateTime"].isNull())
 			contactGroupsObject.updateTime = std::stol(valueContactGroupsContactGroup["UpdateTime"].asString());
+		auto allContactsNode = allContactGroupsNode["Contacts"]["Contact"];
+		for (auto allContactGroupsNodeContactsContact : allContactsNode)
+		{
+			ContactGroup::Contact contactsObject;
+			if(!allContactGroupsNodeContactsContact["ContactId"].isNull())
+				contactsObject.contactId = std::stol(allContactGroupsNodeContactsContact["ContactId"].asString());
+			if(!allContactGroupsNodeContactsContact["ContactName"].isNull())
+				contactsObject.contactName = allContactGroupsNodeContactsContact["ContactName"].asString();
+			if(!allContactGroupsNodeContactsContact["Phone"].isNull())
+				contactsObject.phone = allContactGroupsNodeContactsContact["Phone"].asString();
+			if(!allContactGroupsNodeContactsContact["Email"].isNull())
+				contactsObject.email = allContactGroupsNodeContactsContact["Email"].asString();
+			if(!allContactGroupsNodeContactsContact["UserId"].isNull())
+				contactsObject.userId = allContactGroupsNodeContactsContact["UserId"].asString();
+			if(!allContactGroupsNodeContactsContact["DingRobot"].isNull())
+				contactsObject.dingRobot = allContactGroupsNodeContactsContact["DingRobot"].asString();
+			if(!allContactGroupsNodeContactsContact["CreateTime"].isNull())
+				contactsObject.createTime = std::stol(allContactGroupsNodeContactsContact["CreateTime"].asString());
+			if(!allContactGroupsNodeContactsContact["UpdateTime"].isNull())
+				contactsObject.updateTime = std::stol(allContactGroupsNodeContactsContact["UpdateTime"].asString());
+			if(!allContactGroupsNodeContactsContact["SystemNoc"].isNull())
+				contactsObject.systemNoc = allContactGroupsNodeContactsContact["SystemNoc"].asString() == "true";
+			contactGroupsObject.contacts.push_back(contactsObject);
+		}
 		contactGroups_.push_back(contactGroupsObject);
 	}
 

arms/src/model/SearchAlertRulesResult.cc

@@ -145,7 +145,7 @@ void SearchAlertRulesResult::parse(const std::string &payload)
 		auto allAlertWays = value["AlertWays"]["AlertWay"];
 		for (auto value : allAlertWays)
 			alertRuleEntityObject.alertWays.push_back(value.asString());
-		auto allAlertWay = value["AlertWay"]["AlertWay"];
+		auto allAlertWay = value["AlertWay"]["NocWay"];
 		for (auto value : allAlertWay)
 			alertRuleEntityObject.alertWay.push_back(value.asString());
 		pageBean_.alertRules.push_back(alertRuleEntityObject);

arms/src/model/SearchEventsResult.cc

@@ -57,7 +57,7 @@ void SearchEventsResult::parse(const std::string &payload)
 		if(!pageBeanNodeEventEventItem["AlertType"].isNull())
 			eventItemObject.alertType = std::stoi(pageBeanNodeEventEventItem["AlertType"].asString());
 		if(!pageBeanNodeEventEventItem["EventLevel"].isNull())
-			eventItemObject.eventLevel = std::stoi(pageBeanNodeEventEventItem["EventLevel"].asString());
+			eventItemObject.eventLevel = pageBeanNodeEventEventItem["EventLevel"].asString();
 		if(!pageBeanNodeEventEventItem["Message"].isNull())
 			eventItemObject.message = pageBeanNodeEventEventItem["Message"].asString();
 		if(!pageBeanNodeEventEventItem["AlertId"].isNull())

hbase/CMakeLists.txt

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

hbase/include/alibabacloud/hbase/HBaseClient.h

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

hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBRequest.h

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

hbase/include/alibabacloud/hbase/model/DeleteHBaseHaDBResult.h

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

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

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

hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsResult.h

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

hbase/include/alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeMultiZoneAvailableResourceRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeMultiZoneAvailableResourceRequest();
+				~DescribeMultiZoneAvailableResourceRequest();
+
+				std::string getZoneCombination()const;
+				void setZoneCombination(const std::string& zoneCombination);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getChargeType()const;
+				void setChargeType(const std::string& chargeType);
+
+            private:
+				std::string zoneCombination_;
+				std::string regionId_;
+				std::string chargeType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCEREQUEST_H_

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

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCERESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeMultiZoneAvailableResourceResult : public ServiceResult
+			{
+			public:
+				struct AvailableZone
+				{
+					struct MasterResource
+					{
+						struct InstanceTypeDetail
+						{
+							int mem;
+							int cpu;
+						};
+						InstanceTypeDetail instanceTypeDetail;
+						std::string instanceType;
+					};
+					struct SupportedEngine
+					{
+						struct SupportedEngineVersion
+						{
+							struct SupportedCategoriesItem
+							{
+								struct SupportedStorageType
+								{
+									struct CoreResource
+									{
+										struct DBInstanceStorageRange
+										{
+											int minSize;
+											int stepSize;
+											int maxSize;
+										};
+										struct InstanceTypeDetail1
+										{
+											int mem;
+											int cpu;
+										};
+										InstanceTypeDetail1 instanceTypeDetail1;
+										DBInstanceStorageRange dBInstanceStorageRange;
+										std::string instanceType;
+										int maxCoreCount;
+									};
+									std::string storageType;
+									std::vector<SupportedStorageType::CoreResource> coreResources;
+								};
+								std::string category;
+								std::vector<SupportedCategoriesItem::SupportedStorageType> supportedStorageTypes;
+							};
+							std::string version;
+							std::vector<SupportedEngineVersion::SupportedCategoriesItem> supportedCategories;
+						};
+						std::vector<SupportedEngine::SupportedEngineVersion> supportedEngineVersions;
+						std::string engine;
+					};
+					std::vector<AvailableZone::MasterResource> masterResources;
+					std::string zoneCombination;
+					std::vector<AvailableZone::SupportedEngine> supportedEngines;
+					std::string regionId;
+				};
+
+
+				DescribeMultiZoneAvailableResourceResult();
+				explicit DescribeMultiZoneAvailableResourceResult(const std::string &payload);
+				~DescribeMultiZoneAvailableResourceResult();
+				std::vector<AvailableZone> getAvailableZones()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<AvailableZone> availableZones_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONEAVAILABLERESOURCERESULT_H_

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

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

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

@@ -0,0 +1,154 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERRESULT_H_
+#define ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT DescribeMultiZoneClusterResult : public ServiceResult
+			{
+			public:
+				struct MultiZoneInstanceModel
+				{
+					std::string status;
+					std::string role;
+					bool isLatestVersion;
+					std::string minorVersion;
+					std::string insName;
+				};
+				struct Tag
+				{
+					std::string value;
+					std::string key;
+				};
+
+
+				DescribeMultiZoneClusterResult();
+				explicit DescribeMultiZoneClusterResult(const std::string &payload);
+				~DescribeMultiZoneClusterResult();
+				std::string getModuleStackVersion()const;
+				std::string getStandbyZoneId()const;
+				std::string getCreatedTime()const;
+				std::string getMasterInstanceType()const;
+				std::string getPrimaryVSwitchIds()const;
+				bool getIsDeletionProtection()const;
+				std::string getLogDiskCount()const;
+				int getLogDiskSize()const;
+				int getModuleId()const;
+				std::string getArbiterVSwitchIds()const;
+				std::string getMaintainEndTime()const;
+				std::string getStandbyVSwitchIds()const;
+				std::string getNetworkType()const;
+				std::string getCoreInstanceType()const;
+				std::string getClusterName()const;
+				std::string getMasterDiskType()const;
+				std::vector<Tag> getTags()const;
+				std::string getEngine()const;
+				std::string getMaintainStartTime()const;
+				std::string getArbiterZoneId()const;
+				std::string getMajorVersion()const;
+				std::string getCoreDiskCount()const;
+				std::string getParentId()const;
+				std::string getStatus()const;
+				std::vector<MultiZoneInstanceModel> getMultiZoneInstanceModels()const;
+				std::string getExpireTimeUTC()const;
+				int getMasterDiskSize()const;
+				std::string getPrimaryZoneId()const;
+				std::string getMultiZoneCombination()const;
+				std::string getClusterId()const;
+				std::string getInstanceId()const;
+				int getCoreNodeCount()const;
+				std::string getCreatedTimeUTC()const;
+				int getDuration()const;
+				std::string getLogInstanceType()const;
+				std::string getPayType()const;
+				std::string getInstanceName()const;
+				int getMasterNodeCount()const;
+				bool getAutoRenewal()const;
+				std::string getVpcId()const;
+				std::string getCoreDiskType()const;
+				int getLogNodeCount()const;
+				std::string getLogDiskType()const;
+				std::string getRegionId()const;
+				std::string getExpireTime()const;
+				int getCoreDiskSize()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string moduleStackVersion_;
+				std::string standbyZoneId_;
+				std::string createdTime_;
+				std::string masterInstanceType_;
+				std::string primaryVSwitchIds_;
+				bool isDeletionProtection_;
+				std::string logDiskCount_;
+				int logDiskSize_;
+				int moduleId_;
+				std::string arbiterVSwitchIds_;
+				std::string maintainEndTime_;
+				std::string standbyVSwitchIds_;
+				std::string networkType_;
+				std::string coreInstanceType_;
+				std::string clusterName_;
+				std::string masterDiskType_;
+				std::vector<Tag> tags_;
+				std::string engine_;
+				std::string maintainStartTime_;
+				std::string arbiterZoneId_;
+				std::string majorVersion_;
+				std::string coreDiskCount_;
+				std::string parentId_;
+				std::string status_;
+				std::vector<MultiZoneInstanceModel> multiZoneInstanceModels_;
+				std::string expireTimeUTC_;
+				int masterDiskSize_;
+				std::string primaryZoneId_;
+				std::string multiZoneCombination_;
+				std::string clusterId_;
+				std::string instanceId_;
+				int coreNodeCount_;
+				std::string createdTimeUTC_;
+				int duration_;
+				std::string logInstanceType_;
+				std::string payType_;
+				std::string instanceName_;
+				int masterNodeCount_;
+				bool autoRenewal_;
+				std::string vpcId_;
+				std::string coreDiskType_;
+				int logNodeCount_;
+				std::string logDiskType_;
+				std::string regionId_;
+				std::string expireTime_;
+				int coreDiskSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_DESCRIBEMULTIZONECLUSTERRESULT_H_

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

@@ -0,0 +1,129 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCEREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT EvaluateMultiZoneResourceRequest : public RpcServiceRequest
+			{
+
+			public:
+				EvaluateMultiZoneResourceRequest();
+				~EvaluateMultiZoneResourceRequest();
+
+				std::string getArchVersion()const;
+				void setArchVersion(const std::string& archVersion);
+				std::string getClusterName()const;
+				void setClusterName(const std::string& clusterName);
+				std::string getEngineVersion()const;
+				void setEngineVersion(const std::string& engineVersion);
+				std::string getLogDiskType()const;
+				void setLogDiskType(const std::string& logDiskType);
+				std::string getPrimaryVSwitchId()const;
+				void setPrimaryVSwitchId(const std::string& primaryVSwitchId);
+				std::string getLogInstanceType()const;
+				void setLogInstanceType(const std::string& logInstanceType);
+				int getAutoRenewPeriod()const;
+				void setAutoRenewPeriod(int autoRenewPeriod);
+				int getPeriod()const;
+				void setPeriod(int period);
+				int getLogNodeCount()const;
+				void setLogNodeCount(int logNodeCount);
+				std::string getSecurityIPList()const;
+				void setSecurityIPList(const std::string& securityIPList);
+				std::string getPeriodUnit()const;
+				void setPeriodUnit(const std::string& periodUnit);
+				std::string getCoreDiskType()const;
+				void setCoreDiskType(const std::string& coreDiskType);
+				std::string getArbiterZoneId()const;
+				void setArbiterZoneId(const std::string& arbiterZoneId);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getMultiZoneCombination()const;
+				void setMultiZoneCombination(const std::string& multiZoneCombination);
+				std::string getPrimaryZoneId()const;
+				void setPrimaryZoneId(const std::string& primaryZoneId);
+				std::string getEngine()const;
+				void setEngine(const std::string& engine);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getStandbyVSwitchId()const;
+				void setStandbyVSwitchId(const std::string& standbyVSwitchId);
+				std::string getStandbyZoneId()const;
+				void setStandbyZoneId(const std::string& standbyZoneId);
+				std::string getMasterInstanceType()const;
+				void setMasterInstanceType(const std::string& masterInstanceType);
+				int getCoreNodeCount()const;
+				void setCoreNodeCount(int coreNodeCount);
+				int getLogDiskSize()const;
+				void setLogDiskSize(int logDiskSize);
+				std::string getCoreInstanceType()const;
+				void setCoreInstanceType(const std::string& coreInstanceType);
+				int getCoreDiskSize()const;
+				void setCoreDiskSize(int coreDiskSize);
+				std::string getVpcId()const;
+				void setVpcId(const std::string& vpcId);
+				std::string getPayType()const;
+				void setPayType(const std::string& payType);
+				std::string getArbiterVSwitchId()const;
+				void setArbiterVSwitchId(const std::string& arbiterVSwitchId);
+
+            private:
+				std::string archVersion_;
+				std::string clusterName_;
+				std::string engineVersion_;
+				std::string logDiskType_;
+				std::string primaryVSwitchId_;
+				std::string logInstanceType_;
+				int autoRenewPeriod_;
+				int period_;
+				int logNodeCount_;
+				std::string securityIPList_;
+				std::string periodUnit_;
+				std::string coreDiskType_;
+				std::string arbiterZoneId_;
+				std::string clientToken_;
+				std::string multiZoneCombination_;
+				std::string primaryZoneId_;
+				std::string engine_;
+				std::string regionId_;
+				std::string standbyVSwitchId_;
+				std::string standbyZoneId_;
+				std::string masterInstanceType_;
+				int coreNodeCount_;
+				int logDiskSize_;
+				std::string coreInstanceType_;
+				int coreDiskSize_;
+				std::string vpcId_;
+				std::string payType_;
+				std::string arbiterVSwitchId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_EVALUATEMULTIZONERESOURCEREQUEST_H_

hbase/include/alibabacloud/hbase/model/EvaluateMultiZoneResourceResult.h

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

hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERREQUEST_H_
+#define ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/hbase/HBaseExport.h>
+
+namespace AlibabaCloud
+{
+	namespace HBase
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_HBASE_EXPORT UpgradeMultiZoneClusterRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpgradeMultiZoneClusterRequest();
+				~UpgradeMultiZoneClusterRequest();
+
+				std::string getRunMode()const;
+				void setRunMode(const std::string& runMode);
+				std::string getComponents()const;
+				void setComponents(const std::string& components);
+				std::string getUpgradeInsName()const;
+				void setUpgradeInsName(const std::string& upgradeInsName);
+				std::string getRestartComponents()const;
+				void setRestartComponents(const std::string& restartComponents);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getVersions()const;
+				void setVersions(const std::string& versions);
+
+            private:
+				std::string runMode_;
+				std::string components_;
+				std::string upgradeInsName_;
+				std::string restartComponents_;
+				std::string clusterId_;
+				std::string versions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_HBASE_MODEL_UPGRADEMULTIZONECLUSTERREQUEST_H_

hbase/include/alibabacloud/hbase/model/UpgradeMultiZoneClusterResult.h

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

hbase/src/HBaseClient.cc

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

hbase/src/model/DeleteHBaseHaDBRequest.cc

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

hbase/src/model/DeleteHBaseHaDBResult.cc

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

hbase/src/model/DescribeMultiZoneAvailableRegionsRequest.cc

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

hbase/src/model/DescribeMultiZoneAvailableRegionsResult.cc

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DescribeMultiZoneAvailableRegionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeMultiZoneAvailableRegionsResult::DescribeMultiZoneAvailableRegionsResult() :
+	ServiceResult()
+{}
+
+DescribeMultiZoneAvailableRegionsResult::DescribeMultiZoneAvailableRegionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeMultiZoneAvailableRegionsResult::~DescribeMultiZoneAvailableRegionsResult()
+{}
+
+void DescribeMultiZoneAvailableRegionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRegionsNode = value["Regions"]["Region"];
+	for (auto valueRegionsRegion : allRegionsNode)
+	{
+		Region regionsObject;
+		if(!valueRegionsRegion["LocalName"].isNull())
+			regionsObject.localName = valueRegionsRegion["LocalName"].asString();
+		if(!valueRegionsRegion["RegionEndpoint"].isNull())
+			regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
+		if(!valueRegionsRegion["RegionId"].isNull())
+			regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
+		auto allAvailableCombinesNode = allRegionsNode["AvailableCombines"]["AvailableCombine"];
+		for (auto allRegionsNodeAvailableCombinesAvailableCombine : allAvailableCombinesNode)
+		{
+			Region::AvailableCombine availableCombinesObject;
+			if(!allRegionsNodeAvailableCombinesAvailableCombine["Id"].isNull())
+				availableCombinesObject.id = allRegionsNodeAvailableCombinesAvailableCombine["Id"].asString();
+			auto allZones = value["Zones"]["Zone"];
+			for (auto value : allZones)
+				availableCombinesObject.zones.push_back(value.asString());
+			regionsObject.availableCombines.push_back(availableCombinesObject);
+		}
+		regions_.push_back(regionsObject);
+	}
+
+}
+
+std::vector<DescribeMultiZoneAvailableRegionsResult::Region> DescribeMultiZoneAvailableRegionsResult::getRegions()const
+{
+	return regions_;
+}
+

hbase/src/model/DescribeMultiZoneAvailableResourceRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DescribeMultiZoneAvailableResourceRequest.h>
+
+using AlibabaCloud::HBase::Model::DescribeMultiZoneAvailableResourceRequest;
+
+DescribeMultiZoneAvailableResourceRequest::DescribeMultiZoneAvailableResourceRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "DescribeMultiZoneAvailableResource")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeMultiZoneAvailableResourceRequest::~DescribeMultiZoneAvailableResourceRequest()
+{}
+
+std::string DescribeMultiZoneAvailableResourceRequest::getZoneCombination()const
+{
+	return zoneCombination_;
+}
+
+void DescribeMultiZoneAvailableResourceRequest::setZoneCombination(const std::string& zoneCombination)
+{
+	zoneCombination_ = zoneCombination;
+	setParameter("ZoneCombination", zoneCombination);
+}
+
+std::string DescribeMultiZoneAvailableResourceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeMultiZoneAvailableResourceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DescribeMultiZoneAvailableResourceRequest::getChargeType()const
+{
+	return chargeType_;
+}
+
+void DescribeMultiZoneAvailableResourceRequest::setChargeType(const std::string& chargeType)
+{
+	chargeType_ = chargeType;
+	setParameter("ChargeType", chargeType);
+}
+

hbase/src/model/DescribeMultiZoneAvailableResourceResult.cc

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

hbase/src/model/DescribeMultiZoneClusterRequest.cc

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

hbase/src/model/DescribeMultiZoneClusterResult.cc

@@ -0,0 +1,388 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/DescribeMultiZoneClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::HBase;
+using namespace AlibabaCloud::HBase::Model;
+
+DescribeMultiZoneClusterResult::DescribeMultiZoneClusterResult() :
+	ServiceResult()
+{}
+
+DescribeMultiZoneClusterResult::DescribeMultiZoneClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeMultiZoneClusterResult::~DescribeMultiZoneClusterResult()
+{}
+
+void DescribeMultiZoneClusterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allMultiZoneInstanceModelsNode = value["MultiZoneInstanceModels"]["MultiZoneInstanceModel"];
+	for (auto valueMultiZoneInstanceModelsMultiZoneInstanceModel : allMultiZoneInstanceModelsNode)
+	{
+		MultiZoneInstanceModel multiZoneInstanceModelsObject;
+		if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["InsName"].isNull())
+			multiZoneInstanceModelsObject.insName = valueMultiZoneInstanceModelsMultiZoneInstanceModel["InsName"].asString();
+		if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["IsLatestVersion"].isNull())
+			multiZoneInstanceModelsObject.isLatestVersion = valueMultiZoneInstanceModelsMultiZoneInstanceModel["IsLatestVersion"].asString() == "true";
+		if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["MinorVersion"].isNull())
+			multiZoneInstanceModelsObject.minorVersion = valueMultiZoneInstanceModelsMultiZoneInstanceModel["MinorVersion"].asString();
+		if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["Status"].isNull())
+			multiZoneInstanceModelsObject.status = valueMultiZoneInstanceModelsMultiZoneInstanceModel["Status"].asString();
+		if(!valueMultiZoneInstanceModelsMultiZoneInstanceModel["Role"].isNull())
+			multiZoneInstanceModelsObject.role = valueMultiZoneInstanceModelsMultiZoneInstanceModel["Role"].asString();
+		multiZoneInstanceModels_.push_back(multiZoneInstanceModelsObject);
+	}
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["Key"].isNull())
+			tagsObject.key = valueTagsTag["Key"].asString();
+		if(!valueTagsTag["Value"].isNull())
+			tagsObject.value = valueTagsTag["Value"].asString();
+		tags_.push_back(tagsObject);
+	}
+	if(!value["AutoRenewal"].isNull())
+		autoRenewal_ = value["AutoRenewal"].asString() == "true";
+	if(!value["ClusterId"].isNull())
+		clusterId_ = value["ClusterId"].asString();
+	if(!value["ClusterName"].isNull())
+		clusterName_ = value["ClusterName"].asString();
+	if(!value["CreatedTime"].isNull())
+		createdTime_ = value["CreatedTime"].asString();
+	if(!value["CreatedTimeUTC"].isNull())
+		createdTimeUTC_ = value["CreatedTimeUTC"].asString();
+	if(!value["Duration"].isNull())
+		duration_ = std::stoi(value["Duration"].asString());
+	if(!value["Engine"].isNull())
+		engine_ = value["Engine"].asString();
+	if(!value["ExpireTime"].isNull())
+		expireTime_ = value["ExpireTime"].asString();
+	if(!value["ExpireTimeUTC"].isNull())
+		expireTimeUTC_ = value["ExpireTimeUTC"].asString();
+	if(!value["InstanceId"].isNull())
+		instanceId_ = value["InstanceId"].asString();
+	if(!value["InstanceName"].isNull())
+		instanceName_ = value["InstanceName"].asString();
+	if(!value["IsDeletionProtection"].isNull())
+		isDeletionProtection_ = value["IsDeletionProtection"].asString() == "true";
+	if(!value["MaintainEndTime"].isNull())
+		maintainEndTime_ = value["MaintainEndTime"].asString();
+	if(!value["MaintainStartTime"].isNull())
+		maintainStartTime_ = value["MaintainStartTime"].asString();
+	if(!value["MajorVersion"].isNull())
+		majorVersion_ = value["MajorVersion"].asString();
+	if(!value["MasterDiskSize"].isNull())
+		masterDiskSize_ = std::stoi(value["MasterDiskSize"].asString());
+	if(!value["MasterDiskType"].isNull())
+		masterDiskType_ = value["MasterDiskType"].asString();
+	if(!value["MasterInstanceType"].isNull())
+		masterInstanceType_ = value["MasterInstanceType"].asString();
+	if(!value["MasterNodeCount"].isNull())
+		masterNodeCount_ = std::stoi(value["MasterNodeCount"].asString());
+	if(!value["CoreDiskCount"].isNull())
+		coreDiskCount_ = value["CoreDiskCount"].asString();
+	if(!value["CoreDiskSize"].isNull())
+		coreDiskSize_ = std::stoi(value["CoreDiskSize"].asString());
+	if(!value["CoreDiskType"].isNull())
+		coreDiskType_ = value["CoreDiskType"].asString();
+	if(!value["CoreInstanceType"].isNull())
+		coreInstanceType_ = value["CoreInstanceType"].asString();
+	if(!value["CoreNodeCount"].isNull())
+		coreNodeCount_ = std::stoi(value["CoreNodeCount"].asString());
+	if(!value["LogDiskCount"].isNull())
+		logDiskCount_ = value["LogDiskCount"].asString();
+	if(!value["LogDiskSize"].isNull())
+		logDiskSize_ = std::stoi(value["LogDiskSize"].asString());
+	if(!value["LogDiskType"].isNull())
+		logDiskType_ = value["LogDiskType"].asString();
+	if(!value["LogInstanceType"].isNull())
+		logInstanceType_ = value["LogInstanceType"].asString();
+	if(!value["LogNodeCount"].isNull())
+		logNodeCount_ = std::stoi(value["LogNodeCount"].asString());
+	if(!value["ModuleId"].isNull())
+		moduleId_ = std::stoi(value["ModuleId"].asString());
+	if(!value["ModuleStackVersion"].isNull())
+		moduleStackVersion_ = value["ModuleStackVersion"].asString();
+	if(!value["NetworkType"].isNull())
+		networkType_ = value["NetworkType"].asString();
+	if(!value["ParentId"].isNull())
+		parentId_ = value["ParentId"].asString();
+	if(!value["PayType"].isNull())
+		payType_ = value["PayType"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["MultiZoneCombination"].isNull())
+		multiZoneCombination_ = value["MultiZoneCombination"].asString();
+	if(!value["PrimaryZoneId"].isNull())
+		primaryZoneId_ = value["PrimaryZoneId"].asString();
+	if(!value["PrimaryVSwitchIds"].isNull())
+		primaryVSwitchIds_ = value["PrimaryVSwitchIds"].asString();
+	if(!value["StandbyZoneId"].isNull())
+		standbyZoneId_ = value["StandbyZoneId"].asString();
+	if(!value["StandbyVSwitchIds"].isNull())
+		standbyVSwitchIds_ = value["StandbyVSwitchIds"].asString();
+	if(!value["ArbiterZoneId"].isNull())
+		arbiterZoneId_ = value["ArbiterZoneId"].asString();
+	if(!value["ArbiterVSwitchIds"].isNull())
+		arbiterVSwitchIds_ = value["ArbiterVSwitchIds"].asString();
+	if(!value["VpcId"].isNull())
+		vpcId_ = value["VpcId"].asString();
+
+}
+
+std::string DescribeMultiZoneClusterResult::getModuleStackVersion()const
+{
+	return moduleStackVersion_;
+}
+
+std::string DescribeMultiZoneClusterResult::getStandbyZoneId()const
+{
+	return standbyZoneId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getCreatedTime()const
+{
+	return createdTime_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMasterInstanceType()const
+{
+	return masterInstanceType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getPrimaryVSwitchIds()const
+{
+	return primaryVSwitchIds_;
+}
+
+bool DescribeMultiZoneClusterResult::getIsDeletionProtection()const
+{
+	return isDeletionProtection_;
+}
+
+std::string DescribeMultiZoneClusterResult::getLogDiskCount()const
+{
+	return logDiskCount_;
+}
+
+int DescribeMultiZoneClusterResult::getLogDiskSize()const
+{
+	return logDiskSize_;
+}
+
+int DescribeMultiZoneClusterResult::getModuleId()const
+{
+	return moduleId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getArbiterVSwitchIds()const
+{
+	return arbiterVSwitchIds_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMaintainEndTime()const
+{
+	return maintainEndTime_;
+}
+
+std::string DescribeMultiZoneClusterResult::getStandbyVSwitchIds()const
+{
+	return standbyVSwitchIds_;
+}
+
+std::string DescribeMultiZoneClusterResult::getNetworkType()const
+{
+	return networkType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getCoreInstanceType()const
+{
+	return coreInstanceType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getClusterName()const
+{
+	return clusterName_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMasterDiskType()const
+{
+	return masterDiskType_;
+}
+
+std::vector<DescribeMultiZoneClusterResult::Tag> DescribeMultiZoneClusterResult::getTags()const
+{
+	return tags_;
+}
+
+std::string DescribeMultiZoneClusterResult::getEngine()const
+{
+	return engine_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMaintainStartTime()const
+{
+	return maintainStartTime_;
+}
+
+std::string DescribeMultiZoneClusterResult::getArbiterZoneId()const
+{
+	return arbiterZoneId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMajorVersion()const
+{
+	return majorVersion_;
+}
+
+std::string DescribeMultiZoneClusterResult::getCoreDiskCount()const
+{
+	return coreDiskCount_;
+}
+
+std::string DescribeMultiZoneClusterResult::getParentId()const
+{
+	return parentId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getStatus()const
+{
+	return status_;
+}
+
+std::vector<DescribeMultiZoneClusterResult::MultiZoneInstanceModel> DescribeMultiZoneClusterResult::getMultiZoneInstanceModels()const
+{
+	return multiZoneInstanceModels_;
+}
+
+std::string DescribeMultiZoneClusterResult::getExpireTimeUTC()const
+{
+	return expireTimeUTC_;
+}
+
+int DescribeMultiZoneClusterResult::getMasterDiskSize()const
+{
+	return masterDiskSize_;
+}
+
+std::string DescribeMultiZoneClusterResult::getPrimaryZoneId()const
+{
+	return primaryZoneId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getMultiZoneCombination()const
+{
+	return multiZoneCombination_;
+}
+
+std::string DescribeMultiZoneClusterResult::getClusterId()const
+{
+	return clusterId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getInstanceId()const
+{
+	return instanceId_;
+}
+
+int DescribeMultiZoneClusterResult::getCoreNodeCount()const
+{
+	return coreNodeCount_;
+}
+
+std::string DescribeMultiZoneClusterResult::getCreatedTimeUTC()const
+{
+	return createdTimeUTC_;
+}
+
+int DescribeMultiZoneClusterResult::getDuration()const
+{
+	return duration_;
+}
+
+std::string DescribeMultiZoneClusterResult::getLogInstanceType()const
+{
+	return logInstanceType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getPayType()const
+{
+	return payType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getInstanceName()const
+{
+	return instanceName_;
+}
+
+int DescribeMultiZoneClusterResult::getMasterNodeCount()const
+{
+	return masterNodeCount_;
+}
+
+bool DescribeMultiZoneClusterResult::getAutoRenewal()const
+{
+	return autoRenewal_;
+}
+
+std::string DescribeMultiZoneClusterResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getCoreDiskType()const
+{
+	return coreDiskType_;
+}
+
+int DescribeMultiZoneClusterResult::getLogNodeCount()const
+{
+	return logNodeCount_;
+}
+
+std::string DescribeMultiZoneClusterResult::getLogDiskType()const
+{
+	return logDiskType_;
+}
+
+std::string DescribeMultiZoneClusterResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::string DescribeMultiZoneClusterResult::getExpireTime()const
+{
+	return expireTime_;
+}
+
+int DescribeMultiZoneClusterResult::getCoreDiskSize()const
+{
+	return coreDiskSize_;
+}
+

hbase/src/model/EvaluateMultiZoneResourceRequest.cc

@@ -0,0 +1,337 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/hbase/model/EvaluateMultiZoneResourceRequest.h>
+
+using AlibabaCloud::HBase::Model::EvaluateMultiZoneResourceRequest;
+
+EvaluateMultiZoneResourceRequest::EvaluateMultiZoneResourceRequest() :
+	RpcServiceRequest("hbase", "2019-01-01", "EvaluateMultiZoneResource")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+EvaluateMultiZoneResourceRequest::~EvaluateMultiZoneResourceRequest()
+{}
+
+std::string EvaluateMultiZoneResourceRequest::getArchVersion()const
+{
+	return archVersion_;
+}
+
+void EvaluateMultiZoneResourceRequest::setArchVersion(const std::string& archVersion)
+{
+	archVersion_ = archVersion;
+	setParameter("ArchVersion", archVersion);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getClusterName()const
+{
+	return clusterName_;
+}
+
+void EvaluateMultiZoneResourceRequest::setClusterName(const std::string& clusterName)
+{
+	clusterName_ = clusterName;
+	setParameter("ClusterName", clusterName);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getEngineVersion()const
+{
+	return engineVersion_;
+}
+
+void EvaluateMultiZoneResourceRequest::setEngineVersion(const std::string& engineVersion)
+{
+	engineVersion_ = engineVersion;
+	setParameter("EngineVersion", engineVersion);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getLogDiskType()const
+{
+	return logDiskType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setLogDiskType(const std::string& logDiskType)
+{
+	logDiskType_ = logDiskType;
+	setParameter("LogDiskType", logDiskType);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getPrimaryVSwitchId()const
+{
+	return primaryVSwitchId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setPrimaryVSwitchId(const std::string& primaryVSwitchId)
+{
+	primaryVSwitchId_ = primaryVSwitchId;
+	setParameter("PrimaryVSwitchId", primaryVSwitchId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getLogInstanceType()const
+{
+	return logInstanceType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setLogInstanceType(const std::string& logInstanceType)
+{
+	logInstanceType_ = logInstanceType;
+	setParameter("LogInstanceType", logInstanceType);
+}
+
+int EvaluateMultiZoneResourceRequest::getAutoRenewPeriod()const
+{
+	return autoRenewPeriod_;
+}
+
+void EvaluateMultiZoneResourceRequest::setAutoRenewPeriod(int autoRenewPeriod)
+{
+	autoRenewPeriod_ = autoRenewPeriod;
+	setParameter("AutoRenewPeriod", std::to_string(autoRenewPeriod));
+}
+
+int EvaluateMultiZoneResourceRequest::getPeriod()const
+{
+	return period_;
+}
+
+void EvaluateMultiZoneResourceRequest::setPeriod(int period)
+{
+	period_ = period;
+	setParameter("Period", std::to_string(period));
+}
+
+int EvaluateMultiZoneResourceRequest::getLogNodeCount()const
+{
+	return logNodeCount_;
+}
+
+void EvaluateMultiZoneResourceRequest::setLogNodeCount(int logNodeCount)
+{
+	logNodeCount_ = logNodeCount;
+	setParameter("LogNodeCount", std::to_string(logNodeCount));
+}
+
+std::string EvaluateMultiZoneResourceRequest::getSecurityIPList()const
+{
+	return securityIPList_;
+}
+
+void EvaluateMultiZoneResourceRequest::setSecurityIPList(const std::string& securityIPList)
+{
+	securityIPList_ = securityIPList;
+	setParameter("SecurityIPList", securityIPList);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getPeriodUnit()const
+{
+	return periodUnit_;
+}
+
+void EvaluateMultiZoneResourceRequest::setPeriodUnit(const std::string& periodUnit)
+{
+	periodUnit_ = periodUnit;
+	setParameter("PeriodUnit", periodUnit);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getCoreDiskType()const
+{
+	return coreDiskType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setCoreDiskType(const std::string& coreDiskType)
+{
+	coreDiskType_ = coreDiskType;
+	setParameter("CoreDiskType", coreDiskType);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getArbiterZoneId()const
+{
+	return arbiterZoneId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setArbiterZoneId(const std::string& arbiterZoneId)
+{
+	arbiterZoneId_ = arbiterZoneId;
+	setParameter("ArbiterZoneId", arbiterZoneId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void EvaluateMultiZoneResourceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getMultiZoneCombination()const
+{
+	return multiZoneCombination_;
+}
+
+void EvaluateMultiZoneResourceRequest::setMultiZoneCombination(const std::string& multiZoneCombination)
+{
+	multiZoneCombination_ = multiZoneCombination;
+	setParameter("MultiZoneCombination", multiZoneCombination);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getPrimaryZoneId()const
+{
+	return primaryZoneId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setPrimaryZoneId(const std::string& primaryZoneId)
+{
+	primaryZoneId_ = primaryZoneId;
+	setParameter("PrimaryZoneId", primaryZoneId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getEngine()const
+{
+	return engine_;
+}
+
+void EvaluateMultiZoneResourceRequest::setEngine(const std::string& engine)
+{
+	engine_ = engine;
+	setParameter("Engine", engine);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getStandbyVSwitchId()const
+{
+	return standbyVSwitchId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setStandbyVSwitchId(const std::string& standbyVSwitchId)
+{
+	standbyVSwitchId_ = standbyVSwitchId;
+	setParameter("StandbyVSwitchId", standbyVSwitchId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getStandbyZoneId()const
+{
+	return standbyZoneId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setStandbyZoneId(const std::string& standbyZoneId)
+{
+	standbyZoneId_ = standbyZoneId;
+	setParameter("StandbyZoneId", standbyZoneId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getMasterInstanceType()const
+{
+	return masterInstanceType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setMasterInstanceType(const std::string& masterInstanceType)
+{
+	masterInstanceType_ = masterInstanceType;
+	setParameter("MasterInstanceType", masterInstanceType);
+}
+
+int EvaluateMultiZoneResourceRequest::getCoreNodeCount()const
+{
+	return coreNodeCount_;
+}
+
+void EvaluateMultiZoneResourceRequest::setCoreNodeCount(int coreNodeCount)
+{
+	coreNodeCount_ = coreNodeCount;
+	setParameter("CoreNodeCount", std::to_string(coreNodeCount));
+}
+
+int EvaluateMultiZoneResourceRequest::getLogDiskSize()const
+{
+	return logDiskSize_;
+}
+
+void EvaluateMultiZoneResourceRequest::setLogDiskSize(int logDiskSize)
+{
+	logDiskSize_ = logDiskSize;
+	setParameter("LogDiskSize", std::to_string(logDiskSize));
+}
+
+std::string EvaluateMultiZoneResourceRequest::getCoreInstanceType()const
+{
+	return coreInstanceType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setCoreInstanceType(const std::string& coreInstanceType)
+{
+	coreInstanceType_ = coreInstanceType;
+	setParameter("CoreInstanceType", coreInstanceType);
+}
+
+int EvaluateMultiZoneResourceRequest::getCoreDiskSize()const
+{
+	return coreDiskSize_;
+}
+
+void EvaluateMultiZoneResourceRequest::setCoreDiskSize(int coreDiskSize)
+{
+	coreDiskSize_ = coreDiskSize;
+	setParameter("CoreDiskSize", std::to_string(coreDiskSize));
+}
+
+std::string EvaluateMultiZoneResourceRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setParameter("VpcId", vpcId);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getPayType()const
+{
+	return payType_;
+}
+
+void EvaluateMultiZoneResourceRequest::setPayType(const std::string& payType)
+{
+	payType_ = payType;
+	setParameter("PayType", payType);
+}
+
+std::string EvaluateMultiZoneResourceRequest::getArbiterVSwitchId()const
+{
+	return arbiterVSwitchId_;
+}
+
+void EvaluateMultiZoneResourceRequest::setArbiterVSwitchId(const std::string& arbiterVSwitchId)
+{
+	arbiterVSwitchId_ = arbiterVSwitchId;
+	setParameter("ArbiterVSwitchId", arbiterVSwitchId);
+}
+

hbase/src/model/EvaluateMultiZoneResourceResult.cc

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

hbase/src/model/UpgradeMultiZoneClusterRequest.cc

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

hbase/src/model/UpgradeMultiZoneClusterResult.cc

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

live/CMakeLists.txt

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

live/include/alibabacloud/live/LiveClient.h

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

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

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

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

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

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

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LIVE_MODEL_ADDRTSLIVESTREAMTRANSCODEREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_ADDRTSLIVESTREAMTRANSCODEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT AddRtsLiveStreamTranscodeRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddRtsLiveStreamTranscodeRequest();
+				~AddRtsLiveStreamTranscodeRequest();
+
+				std::string get_Template()const;
+				void set_Template(const std::string& _template);
+				bool getDeleteBframes()const;
+				void setDeleteBframes(bool deleteBframes);
+				std::string getGop()const;
+				void setGop(const std::string& gop);
+				bool getOpus()const;
+				void setOpus(bool opus);
+				std::string getAudioCodec()const;
+				void setAudioCodec(const std::string& audioCodec);
+				std::string getTemplateType()const;
+				void setTemplateType(const std::string& templateType);
+				std::string getAudioProfile()const;
+				void setAudioProfile(const std::string& audioProfile);
+				int getHeight()const;
+				void setHeight(int height);
+				std::string getApp()const;
+				void setApp(const std::string& app);
+				int getAudioChannelNum()const;
+				void setAudioChannelNum(int audioChannelNum);
+				int getProfile()const;
+				void setProfile(int profile);
+				int getFPS()const;
+				void setFPS(int fPS);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getAudioRate()const;
+				void setAudioRate(int audioRate);
+				int getAudioBitrate()const;
+				void setAudioBitrate(int audioBitrate);
+				std::string getDomain()const;
+				void setDomain(const std::string& domain);
+				int getWidth()const;
+				void setWidth(int width);
+				int getVideoBitrate()const;
+				void setVideoBitrate(int videoBitrate);
+
+            private:
+				std::string _template_;
+				bool deleteBframes_;
+				std::string gop_;
+				bool opus_;
+				std::string audioCodec_;
+				std::string templateType_;
+				std::string audioProfile_;
+				int height_;
+				std::string app_;
+				int audioChannelNum_;
+				int profile_;
+				int fPS_;
+				long ownerId_;
+				int audioRate_;
+				int audioBitrate_;
+				std::string domain_;
+				int width_;
+				int videoBitrate_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_ADDRTSLIVESTREAMTRANSCODEREQUEST_H_

live/include/alibabacloud/live/model/AddRtsLiveStreamTranscodeResult.h

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

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

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

live/include/alibabacloud/live/model/DescribeLiveDomainCertificateInfoResult.h

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

live/include/alibabacloud/live/model/DescribeLiveDomainLimitRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainLimitRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLiveDomainLimitRequest();
+				~DescribeLiveDomainLimitRequest();
+
+				std::string getLiveapiRequestFrom()const;
+				void setLiveapiRequestFrom(const std::string& liveapiRequestFrom);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string liveapiRequestFrom_;
+				std::string domainName_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINLIMITREQUEST_H_

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

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

live/include/alibabacloud/live/model/DescribeLiveDomainTimeShiftDataRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATAREQUEST_H_
+#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/live/LiveExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Live
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LIVE_EXPORT DescribeLiveDomainTimeShiftDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLiveDomainTimeShiftDataRequest();
+				~DescribeLiveDomainTimeShiftDataRequest();
+
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+
+            private:
+				std::string startTime_;
+				std::string domainName_;
+				std::string endTime_;
+				long ownerId_;
+				std::string interval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEDOMAINTIMESHIFTDATAREQUEST_H_

live/include/alibabacloud/live/model/DescribeLiveDomainTimeShiftDataResult.h

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

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

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

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

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

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

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

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

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

live/src/LiveClient.cc

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

live/src/model/AddLiveAppSnapshotConfigRequest.cc

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

live/src/model/AddLivePullStreamInfoConfigRequest.cc

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

live/src/model/AddRtsLiveStreamTranscodeRequest.cc

@@ -0,0 +1,227 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/live/model/AddRtsLiveStreamTranscodeRequest.h>
+
+using AlibabaCloud::Live::Model::AddRtsLiveStreamTranscodeRequest;
+
+AddRtsLiveStreamTranscodeRequest::AddRtsLiveStreamTranscodeRequest() :
+	RpcServiceRequest("live", "2016-11-01", "AddRtsLiveStreamTranscode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddRtsLiveStreamTranscodeRequest::~AddRtsLiveStreamTranscodeRequest()
+{}
+
+std::string AddRtsLiveStreamTranscodeRequest::get_Template()const
+{
+	return _template_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::set_Template(const std::string& _template)
+{
+	_template_ = _template;
+	setParameter("_Template", _template);
+}
+
+bool AddRtsLiveStreamTranscodeRequest::getDeleteBframes()const
+{
+	return deleteBframes_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setDeleteBframes(bool deleteBframes)
+{
+	deleteBframes_ = deleteBframes;
+	setParameter("DeleteBframes", deleteBframes ? "true" : "false");
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getGop()const
+{
+	return gop_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setGop(const std::string& gop)
+{
+	gop_ = gop;
+	setParameter("Gop", gop);
+}
+
+bool AddRtsLiveStreamTranscodeRequest::getOpus()const
+{
+	return opus_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setOpus(bool opus)
+{
+	opus_ = opus;
+	setParameter("Opus", opus ? "true" : "false");
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getAudioCodec()const
+{
+	return audioCodec_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioCodec(const std::string& audioCodec)
+{
+	audioCodec_ = audioCodec;
+	setParameter("AudioCodec", audioCodec);
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getTemplateType()const
+{
+	return templateType_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setTemplateType(const std::string& templateType)
+{
+	templateType_ = templateType;
+	setParameter("TemplateType", templateType);
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getAudioProfile()const
+{
+	return audioProfile_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioProfile(const std::string& audioProfile)
+{
+	audioProfile_ = audioProfile;
+	setParameter("AudioProfile", audioProfile);
+}
+
+int AddRtsLiveStreamTranscodeRequest::getHeight()const
+{
+	return height_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setHeight(int height)
+{
+	height_ = height;
+	setParameter("Height", std::to_string(height));
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getApp()const
+{
+	return app_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setApp(const std::string& app)
+{
+	app_ = app;
+	setParameter("App", app);
+}
+
+int AddRtsLiveStreamTranscodeRequest::getAudioChannelNum()const
+{
+	return audioChannelNum_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioChannelNum(int audioChannelNum)
+{
+	audioChannelNum_ = audioChannelNum;
+	setParameter("AudioChannelNum", std::to_string(audioChannelNum));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getProfile()const
+{
+	return profile_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setProfile(int profile)
+{
+	profile_ = profile;
+	setParameter("Profile", std::to_string(profile));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getFPS()const
+{
+	return fPS_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setFPS(int fPS)
+{
+	fPS_ = fPS;
+	setParameter("FPS", std::to_string(fPS));
+}
+
+long AddRtsLiveStreamTranscodeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getAudioRate()const
+{
+	return audioRate_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioRate(int audioRate)
+{
+	audioRate_ = audioRate;
+	setParameter("AudioRate", std::to_string(audioRate));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getAudioBitrate()const
+{
+	return audioBitrate_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setAudioBitrate(int audioBitrate)
+{
+	audioBitrate_ = audioBitrate;
+	setParameter("AudioBitrate", std::to_string(audioBitrate));
+}
+
+std::string AddRtsLiveStreamTranscodeRequest::getDomain()const
+{
+	return domain_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setDomain(const std::string& domain)
+{
+	domain_ = domain;
+	setParameter("Domain", domain);
+}
+
+int AddRtsLiveStreamTranscodeRequest::getWidth()const
+{
+	return width_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setWidth(int width)
+{
+	width_ = width;
+	setParameter("Width", std::to_string(width));
+}
+
+int AddRtsLiveStreamTranscodeRequest::getVideoBitrate()const
+{
+	return videoBitrate_;
+}
+
+void AddRtsLiveStreamTranscodeRequest::setVideoBitrate(int videoBitrate)
+{
+	videoBitrate_ = videoBitrate;
+	setParameter("VideoBitrate", std::to_string(videoBitrate));
+}
+

live/src/model/AddRtsLiveStreamTranscodeResult.cc

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

live/src/model/DescribeLiveDomainCertificateInfoRequest.cc

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

live/src/model/DescribeLiveDomainCertificateInfoResult.cc

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/live/model/DescribeLiveDomainCertificateInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Live;
+using namespace AlibabaCloud::Live::Model;
+
+DescribeLiveDomainCertificateInfoResult::DescribeLiveDomainCertificateInfoResult() :
+	ServiceResult()
+{}
+
+DescribeLiveDomainCertificateInfoResult::DescribeLiveDomainCertificateInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLiveDomainCertificateInfoResult::~DescribeLiveDomainCertificateInfoResult()
+{}
+
+void DescribeLiveDomainCertificateInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allCertInfosNode = value["CertInfos"]["CertInfo"];
+	for (auto valueCertInfosCertInfo : allCertInfosNode)
+	{
+		CertInfo certInfosObject;
+		if(!valueCertInfosCertInfo["DomainName"].isNull())
+			certInfosObject.domainName = valueCertInfosCertInfo["DomainName"].asString();
+		if(!valueCertInfosCertInfo["CertName"].isNull())
+			certInfosObject.certName = valueCertInfosCertInfo["CertName"].asString();
+		if(!valueCertInfosCertInfo["CertDomainName"].isNull())
+			certInfosObject.certDomainName = valueCertInfosCertInfo["CertDomainName"].asString();
+		if(!valueCertInfosCertInfo["CertExpireTime"].isNull())
+			certInfosObject.certExpireTime = valueCertInfosCertInfo["CertExpireTime"].asString();
+		if(!valueCertInfosCertInfo["CertLife"].isNull())
+			certInfosObject.certLife = valueCertInfosCertInfo["CertLife"].asString();
+		if(!valueCertInfosCertInfo["CertOrg"].isNull())
+			certInfosObject.certOrg = valueCertInfosCertInfo["CertOrg"].asString();
+		if(!valueCertInfosCertInfo["CertType"].isNull())
+			certInfosObject.certType = valueCertInfosCertInfo["CertType"].asString();
+		if(!valueCertInfosCertInfo["SSLProtocol"].isNull())
+			certInfosObject.sSLProtocol = valueCertInfosCertInfo["SSLProtocol"].asString();
+		if(!valueCertInfosCertInfo["Status"].isNull())
+			certInfosObject.status = valueCertInfosCertInfo["Status"].asString();
+		if(!valueCertInfosCertInfo["SSLPub"].isNull())
+			certInfosObject.sSLPub = valueCertInfosCertInfo["SSLPub"].asString();
+		certInfos_.push_back(certInfosObject);
+	}
+
+}
+
+std::vector<DescribeLiveDomainCertificateInfoResult::CertInfo> DescribeLiveDomainCertificateInfoResult::getCertInfos()const
+{
+	return certInfos_;
+}
+

live/src/model/DescribeLiveDomainLimitRequest.cc

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

live/src/model/DescribeLiveDomainLimitResult.cc

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

live/src/model/DescribeLiveDomainTimeShiftDataRequest.cc

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

live/src/model/DescribeLiveDomainTimeShiftDataResult.cc

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

live/src/model/DescribeLivePullStreamConfigRequest.cc

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

live/src/model/DescribeLivePullStreamConfigResult.cc

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

live/src/model/DescribeLiveSnapshotConfigResult.cc

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

live/src/model/DescribeLiveStreamTranscodeInfoResult.cc

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

live/src/model/UnTagLiveResourcesRequest.cc

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

live/src/model/UpdateLiveAppSnapshotConfigRequest.cc

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

onsmqtt/CMakeLists.txt

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