Added param for ActivateLicenseResponse .

VERSION

@@ -1 +1 @@
-1.36.1949
+1.36.1950

mseap/CMakeLists.txt

@@ -0,0 +1,146 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(mseap_public_header 
+	include/alibabacloud/mseap/MseapClient.h
+	include/alibabacloud/mseap/MseapExport.h )
+
+set(mseap_public_header_model 
+	include/alibabacloud/mseap/model/ActivateLicenseRequest.h
+	include/alibabacloud/mseap/model/ActivateLicenseResult.h
+	include/alibabacloud/mseap/model/CallbackTaskRequest.h
+	include/alibabacloud/mseap/model/CallbackTaskResult.h
+	include/alibabacloud/mseap/model/DescribeAgreementStatusRequest.h
+	include/alibabacloud/mseap/model/DescribeAgreementStatusResult.h
+	include/alibabacloud/mseap/model/GenerateUploadFilePolicyForPartnerRequest.h
+	include/alibabacloud/mseap/model/GenerateUploadFilePolicyForPartnerResult.h
+	include/alibabacloud/mseap/model/GetNodeByFlowIdRequest.h
+	include/alibabacloud/mseap/model/GetNodeByFlowIdResult.h
+	include/alibabacloud/mseap/model/GetNodeByTemplateIdRequest.h
+	include/alibabacloud/mseap/model/GetNodeByTemplateIdResult.h
+	include/alibabacloud/mseap/model/GetProxyByTypeRequest.h
+	include/alibabacloud/mseap/model/GetProxyByTypeResult.h
+	include/alibabacloud/mseap/model/GetRedisValueRequest.h
+	include/alibabacloud/mseap/model/GetRedisValueResult.h
+	include/alibabacloud/mseap/model/GetVariableRequest.h
+	include/alibabacloud/mseap/model/GetVariableResult.h
+	include/alibabacloud/mseap/model/IdentifyCodeRequest.h
+	include/alibabacloud/mseap/model/IdentifyCodeResult.h
+	include/alibabacloud/mseap/model/PullRpaModelRequest.h
+	include/alibabacloud/mseap/model/PullRpaModelResult.h
+	include/alibabacloud/mseap/model/PullTaskRequest.h
+	include/alibabacloud/mseap/model/PullTaskResult.h
+	include/alibabacloud/mseap/model/PushRpaTaskRequest.h
+	include/alibabacloud/mseap/model/PushRpaTaskResult.h
+	include/alibabacloud/mseap/model/PushRpaTaskDetailRequest.h
+	include/alibabacloud/mseap/model/PushRpaTaskDetailResult.h
+	include/alibabacloud/mseap/model/SetRedisValueRequest.h
+	include/alibabacloud/mseap/model/SetRedisValueResult.h
+	include/alibabacloud/mseap/model/UpdateAgreementStatusRequest.h
+	include/alibabacloud/mseap/model/UpdateAgreementStatusResult.h )
+
+set(mseap_src 
+	src/MseapClient.cc
+	src/model/ActivateLicenseRequest.cc
+	src/model/ActivateLicenseResult.cc
+	src/model/CallbackTaskRequest.cc
+	src/model/CallbackTaskResult.cc
+	src/model/DescribeAgreementStatusRequest.cc
+	src/model/DescribeAgreementStatusResult.cc
+	src/model/GenerateUploadFilePolicyForPartnerRequest.cc
+	src/model/GenerateUploadFilePolicyForPartnerResult.cc
+	src/model/GetNodeByFlowIdRequest.cc
+	src/model/GetNodeByFlowIdResult.cc
+	src/model/GetNodeByTemplateIdRequest.cc
+	src/model/GetNodeByTemplateIdResult.cc
+	src/model/GetProxyByTypeRequest.cc
+	src/model/GetProxyByTypeResult.cc
+	src/model/GetRedisValueRequest.cc
+	src/model/GetRedisValueResult.cc
+	src/model/GetVariableRequest.cc
+	src/model/GetVariableResult.cc
+	src/model/IdentifyCodeRequest.cc
+	src/model/IdentifyCodeResult.cc
+	src/model/PullRpaModelRequest.cc
+	src/model/PullRpaModelResult.cc
+	src/model/PullTaskRequest.cc
+	src/model/PullTaskResult.cc
+	src/model/PushRpaTaskRequest.cc
+	src/model/PushRpaTaskResult.cc
+	src/model/PushRpaTaskDetailRequest.cc
+	src/model/PushRpaTaskDetailResult.cc
+	src/model/SetRedisValueRequest.cc
+	src/model/SetRedisValueResult.cc
+	src/model/UpdateAgreementStatusRequest.cc
+	src/model/UpdateAgreementStatusResult.cc )
+
+add_library(mseap ${LIB_TYPE}
+	${mseap_public_header}
+	${mseap_public_header_model}
+	${mseap_src})
+
+set_target_properties(mseap
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}mseap
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(mseap
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_MSEAP_LIBRARY)
+endif()
+
+target_include_directories(mseap
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(mseap
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(mseap
+		jsoncpp)
+	target_include_directories(mseap
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(mseap
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(mseap
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(mseap
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(mseap
+		jsoncpp)
+endif()
+
+install(FILES ${mseap_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/mseap)
+install(FILES ${mseap_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/mseap/model)
+install(TARGETS mseap
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

mseap/include/alibabacloud/mseap/MseapClient.h

@@ -0,0 +1,174 @@
+/*
+ * 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_MSEAP_MSEAPCLIENT_H_
+#define ALIBABACLOUD_MSEAP_MSEAPCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "MseapExport.h"
+#include "model/ActivateLicenseRequest.h"
+#include "model/ActivateLicenseResult.h"
+#include "model/CallbackTaskRequest.h"
+#include "model/CallbackTaskResult.h"
+#include "model/DescribeAgreementStatusRequest.h"
+#include "model/DescribeAgreementStatusResult.h"
+#include "model/GenerateUploadFilePolicyForPartnerRequest.h"
+#include "model/GenerateUploadFilePolicyForPartnerResult.h"
+#include "model/GetNodeByFlowIdRequest.h"
+#include "model/GetNodeByFlowIdResult.h"
+#include "model/GetNodeByTemplateIdRequest.h"
+#include "model/GetNodeByTemplateIdResult.h"
+#include "model/GetProxyByTypeRequest.h"
+#include "model/GetProxyByTypeResult.h"
+#include "model/GetRedisValueRequest.h"
+#include "model/GetRedisValueResult.h"
+#include "model/GetVariableRequest.h"
+#include "model/GetVariableResult.h"
+#include "model/IdentifyCodeRequest.h"
+#include "model/IdentifyCodeResult.h"
+#include "model/PullRpaModelRequest.h"
+#include "model/PullRpaModelResult.h"
+#include "model/PullTaskRequest.h"
+#include "model/PullTaskResult.h"
+#include "model/PushRpaTaskRequest.h"
+#include "model/PushRpaTaskResult.h"
+#include "model/PushRpaTaskDetailRequest.h"
+#include "model/PushRpaTaskDetailResult.h"
+#include "model/SetRedisValueRequest.h"
+#include "model/SetRedisValueResult.h"
+#include "model/UpdateAgreementStatusRequest.h"
+#include "model/UpdateAgreementStatusResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Mseap
+	{
+		class ALIBABACLOUD_MSEAP_EXPORT MseapClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::ActivateLicenseResult> ActivateLicenseOutcome;
+			typedef std::future<ActivateLicenseOutcome> ActivateLicenseOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::ActivateLicenseRequest&, const ActivateLicenseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ActivateLicenseAsyncHandler;
+			typedef Outcome<Error, Model::CallbackTaskResult> CallbackTaskOutcome;
+			typedef std::future<CallbackTaskOutcome> CallbackTaskOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::CallbackTaskRequest&, const CallbackTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CallbackTaskAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAgreementStatusResult> DescribeAgreementStatusOutcome;
+			typedef std::future<DescribeAgreementStatusOutcome> DescribeAgreementStatusOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::DescribeAgreementStatusRequest&, const DescribeAgreementStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAgreementStatusAsyncHandler;
+			typedef Outcome<Error, Model::GenerateUploadFilePolicyForPartnerResult> GenerateUploadFilePolicyForPartnerOutcome;
+			typedef std::future<GenerateUploadFilePolicyForPartnerOutcome> GenerateUploadFilePolicyForPartnerOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::GenerateUploadFilePolicyForPartnerRequest&, const GenerateUploadFilePolicyForPartnerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenerateUploadFilePolicyForPartnerAsyncHandler;
+			typedef Outcome<Error, Model::GetNodeByFlowIdResult> GetNodeByFlowIdOutcome;
+			typedef std::future<GetNodeByFlowIdOutcome> GetNodeByFlowIdOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::GetNodeByFlowIdRequest&, const GetNodeByFlowIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNodeByFlowIdAsyncHandler;
+			typedef Outcome<Error, Model::GetNodeByTemplateIdResult> GetNodeByTemplateIdOutcome;
+			typedef std::future<GetNodeByTemplateIdOutcome> GetNodeByTemplateIdOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::GetNodeByTemplateIdRequest&, const GetNodeByTemplateIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNodeByTemplateIdAsyncHandler;
+			typedef Outcome<Error, Model::GetProxyByTypeResult> GetProxyByTypeOutcome;
+			typedef std::future<GetProxyByTypeOutcome> GetProxyByTypeOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::GetProxyByTypeRequest&, const GetProxyByTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetProxyByTypeAsyncHandler;
+			typedef Outcome<Error, Model::GetRedisValueResult> GetRedisValueOutcome;
+			typedef std::future<GetRedisValueOutcome> GetRedisValueOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::GetRedisValueRequest&, const GetRedisValueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetRedisValueAsyncHandler;
+			typedef Outcome<Error, Model::GetVariableResult> GetVariableOutcome;
+			typedef std::future<GetVariableOutcome> GetVariableOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::GetVariableRequest&, const GetVariableOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVariableAsyncHandler;
+			typedef Outcome<Error, Model::IdentifyCodeResult> IdentifyCodeOutcome;
+			typedef std::future<IdentifyCodeOutcome> IdentifyCodeOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::IdentifyCodeRequest&, const IdentifyCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> IdentifyCodeAsyncHandler;
+			typedef Outcome<Error, Model::PullRpaModelResult> PullRpaModelOutcome;
+			typedef std::future<PullRpaModelOutcome> PullRpaModelOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::PullRpaModelRequest&, const PullRpaModelOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PullRpaModelAsyncHandler;
+			typedef Outcome<Error, Model::PullTaskResult> PullTaskOutcome;
+			typedef std::future<PullTaskOutcome> PullTaskOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::PullTaskRequest&, const PullTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PullTaskAsyncHandler;
+			typedef Outcome<Error, Model::PushRpaTaskResult> PushRpaTaskOutcome;
+			typedef std::future<PushRpaTaskOutcome> PushRpaTaskOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::PushRpaTaskRequest&, const PushRpaTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PushRpaTaskAsyncHandler;
+			typedef Outcome<Error, Model::PushRpaTaskDetailResult> PushRpaTaskDetailOutcome;
+			typedef std::future<PushRpaTaskDetailOutcome> PushRpaTaskDetailOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::PushRpaTaskDetailRequest&, const PushRpaTaskDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PushRpaTaskDetailAsyncHandler;
+			typedef Outcome<Error, Model::SetRedisValueResult> SetRedisValueOutcome;
+			typedef std::future<SetRedisValueOutcome> SetRedisValueOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::SetRedisValueRequest&, const SetRedisValueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetRedisValueAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAgreementStatusResult> UpdateAgreementStatusOutcome;
+			typedef std::future<UpdateAgreementStatusOutcome> UpdateAgreementStatusOutcomeCallable;
+			typedef std::function<void(const MseapClient*, const Model::UpdateAgreementStatusRequest&, const UpdateAgreementStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAgreementStatusAsyncHandler;
+
+			MseapClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			MseapClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			MseapClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~MseapClient();
+			ActivateLicenseOutcome activateLicense(const Model::ActivateLicenseRequest &request)const;
+			void activateLicenseAsync(const Model::ActivateLicenseRequest& request, const ActivateLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ActivateLicenseOutcomeCallable activateLicenseCallable(const Model::ActivateLicenseRequest& request) const;
+			CallbackTaskOutcome callbackTask(const Model::CallbackTaskRequest &request)const;
+			void callbackTaskAsync(const Model::CallbackTaskRequest& request, const CallbackTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CallbackTaskOutcomeCallable callbackTaskCallable(const Model::CallbackTaskRequest& request) const;
+			DescribeAgreementStatusOutcome describeAgreementStatus(const Model::DescribeAgreementStatusRequest &request)const;
+			void describeAgreementStatusAsync(const Model::DescribeAgreementStatusRequest& request, const DescribeAgreementStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAgreementStatusOutcomeCallable describeAgreementStatusCallable(const Model::DescribeAgreementStatusRequest& request) const;
+			GenerateUploadFilePolicyForPartnerOutcome generateUploadFilePolicyForPartner(const Model::GenerateUploadFilePolicyForPartnerRequest &request)const;
+			void generateUploadFilePolicyForPartnerAsync(const Model::GenerateUploadFilePolicyForPartnerRequest& request, const GenerateUploadFilePolicyForPartnerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenerateUploadFilePolicyForPartnerOutcomeCallable generateUploadFilePolicyForPartnerCallable(const Model::GenerateUploadFilePolicyForPartnerRequest& request) const;
+			GetNodeByFlowIdOutcome getNodeByFlowId(const Model::GetNodeByFlowIdRequest &request)const;
+			void getNodeByFlowIdAsync(const Model::GetNodeByFlowIdRequest& request, const GetNodeByFlowIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNodeByFlowIdOutcomeCallable getNodeByFlowIdCallable(const Model::GetNodeByFlowIdRequest& request) const;
+			GetNodeByTemplateIdOutcome getNodeByTemplateId(const Model::GetNodeByTemplateIdRequest &request)const;
+			void getNodeByTemplateIdAsync(const Model::GetNodeByTemplateIdRequest& request, const GetNodeByTemplateIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNodeByTemplateIdOutcomeCallable getNodeByTemplateIdCallable(const Model::GetNodeByTemplateIdRequest& request) const;
+			GetProxyByTypeOutcome getProxyByType(const Model::GetProxyByTypeRequest &request)const;
+			void getProxyByTypeAsync(const Model::GetProxyByTypeRequest& request, const GetProxyByTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetProxyByTypeOutcomeCallable getProxyByTypeCallable(const Model::GetProxyByTypeRequest& request) const;
+			GetRedisValueOutcome getRedisValue(const Model::GetRedisValueRequest &request)const;
+			void getRedisValueAsync(const Model::GetRedisValueRequest& request, const GetRedisValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetRedisValueOutcomeCallable getRedisValueCallable(const Model::GetRedisValueRequest& request) const;
+			GetVariableOutcome getVariable(const Model::GetVariableRequest &request)const;
+			void getVariableAsync(const Model::GetVariableRequest& request, const GetVariableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVariableOutcomeCallable getVariableCallable(const Model::GetVariableRequest& request) const;
+			IdentifyCodeOutcome identifyCode(const Model::IdentifyCodeRequest &request)const;
+			void identifyCodeAsync(const Model::IdentifyCodeRequest& request, const IdentifyCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			IdentifyCodeOutcomeCallable identifyCodeCallable(const Model::IdentifyCodeRequest& request) const;
+			PullRpaModelOutcome pullRpaModel(const Model::PullRpaModelRequest &request)const;
+			void pullRpaModelAsync(const Model::PullRpaModelRequest& request, const PullRpaModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PullRpaModelOutcomeCallable pullRpaModelCallable(const Model::PullRpaModelRequest& request) const;
+			PullTaskOutcome pullTask(const Model::PullTaskRequest &request)const;
+			void pullTaskAsync(const Model::PullTaskRequest& request, const PullTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PullTaskOutcomeCallable pullTaskCallable(const Model::PullTaskRequest& request) const;
+			PushRpaTaskOutcome pushRpaTask(const Model::PushRpaTaskRequest &request)const;
+			void pushRpaTaskAsync(const Model::PushRpaTaskRequest& request, const PushRpaTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PushRpaTaskOutcomeCallable pushRpaTaskCallable(const Model::PushRpaTaskRequest& request) const;
+			PushRpaTaskDetailOutcome pushRpaTaskDetail(const Model::PushRpaTaskDetailRequest &request)const;
+			void pushRpaTaskDetailAsync(const Model::PushRpaTaskDetailRequest& request, const PushRpaTaskDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PushRpaTaskDetailOutcomeCallable pushRpaTaskDetailCallable(const Model::PushRpaTaskDetailRequest& request) const;
+			SetRedisValueOutcome setRedisValue(const Model::SetRedisValueRequest &request)const;
+			void setRedisValueAsync(const Model::SetRedisValueRequest& request, const SetRedisValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetRedisValueOutcomeCallable setRedisValueCallable(const Model::SetRedisValueRequest& request) const;
+			UpdateAgreementStatusOutcome updateAgreementStatus(const Model::UpdateAgreementStatusRequest &request)const;
+			void updateAgreementStatusAsync(const Model::UpdateAgreementStatusRequest& request, const UpdateAgreementStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAgreementStatusOutcomeCallable updateAgreementStatusCallable(const Model::UpdateAgreementStatusRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_MSEAP_MSEAPCLIENT_H_

mseap/include/alibabacloud/mseap/MseapExport.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSEAP_MSEAPEXPORT_H_
+#define ALIBABACLOUD_MSEAP_MSEAPEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_MSEAP_LIBRARY)
+#		define ALIBABACLOUD_MSEAP_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_MSEAP_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_MSEAP_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_MSEAP_MSEAPEXPORT_H_

mseap/include/alibabacloud/mseap/model/ActivateLicenseRequest.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_MSEAP_MODEL_ACTIVATELICENSEREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_ACTIVATELICENSEREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT ActivateLicenseRequest : public RpcServiceRequest {
+public:
+	ActivateLicenseRequest();
+	~ActivateLicenseRequest();
+	std::string getLicenseNo() const;
+	void setLicenseNo(const std::string &licenseNo);
+	std::string getBizType() const;
+	void setBizType(const std::string &bizType);
+	std::string getLicensePublisher() const;
+	void setLicensePublisher(const std::string &licensePublisher);
+	std::string getBizId() const;
+	void setBizId(const std::string &bizId);
+	std::string getLicenseCode() const;
+	void setLicenseCode(const std::string &licenseCode);
+
+private:
+	std::string licenseNo_;
+	std::string bizType_;
+	std::string licensePublisher_;
+	std::string bizId_;
+	std::string licenseCode_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_ACTIVATELICENSEREQUEST_H_

mseap/include/alibabacloud/mseap/model/ActivateLicenseResult.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_MSEAP_MODEL_ACTIVATELICENSERESULT_H_
+#define ALIBABACLOUD_MSEAP_MODEL_ACTIVATELICENSERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mseap/MseapExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mseap
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSEAP_EXPORT ActivateLicenseResult : public ServiceResult
+			{
+			public:
+
+
+				ActivateLicenseResult();
+				explicit ActivateLicenseResult(const std::string &payload);
+				~ActivateLicenseResult();
+				bool getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSEAP_MODEL_ACTIVATELICENSERESULT_H_

mseap/include/alibabacloud/mseap/model/CallbackTaskRequest.h

@@ -0,0 +1,102 @@
+/*
+ * 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_MSEAP_MODEL_CALLBACKTASKREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_CALLBACKTASKREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT CallbackTaskRequest : public RpcServiceRequest {
+public:
+	CallbackTaskRequest();
+	~CallbackTaskRequest();
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	std::string getOutTaskId() const;
+	void setOutTaskId(const std::string &outTaskId);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	bool getUserMfaPresent() const;
+	void setUserMfaPresent(bool userMfaPresent);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	std::string getTaskId() const;
+	void setTaskId(const std::string &taskId);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getTaskType() const;
+	void setTaskType(const std::string &taskType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	std::string getOrderId() const;
+	void setOrderId(const std::string &orderId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	std::string getPrincipalKey() const;
+	void setPrincipalKey(const std::string &principalKey);
+	bool getUserCallerSecurityTransport() const;
+	void setUserCallerSecurityTransport(bool userCallerSecurityTransport);
+	std::string getBizCode() const;
+	void setBizCode(const std::string &bizCode);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getTaskData() const;
+	void setTaskData(const std::string &taskData);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+
+private:
+	long userCallerParentId_;
+	std::string outTaskId_;
+	std::string apiType_;
+	bool userMfaPresent_;
+	std::string userKp_;
+	std::string lang_;
+	std::string taskId_;
+	std::string userCallerType_;
+	std::string taskType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	std::string orderId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	std::string principalKey_;
+	bool userCallerSecurityTransport_;
+	std::string bizCode_;
+	std::string userClientIp_;
+	std::string taskData_;
+	std::string bid_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_CALLBACKTASKREQUEST_H_

mseap/include/alibabacloud/mseap/model/CallbackTaskResult.h

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

mseap/include/alibabacloud/mseap/model/DescribeAgreementStatusRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_MSEAP_MODEL_DESCRIBEAGREEMENTSTATUSREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_DESCRIBEAGREEMENTSTATUSREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT DescribeAgreementStatusRequest : public RpcServiceRequest {
+public:
+	DescribeAgreementStatusRequest();
+	~DescribeAgreementStatusRequest();
+	std::string getAgreementCode() const;
+	void setAgreementCode(const std::string &agreementCode);
+
+private:
+	std::string agreementCode_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_DESCRIBEAGREEMENTSTATUSREQUEST_H_

mseap/include/alibabacloud/mseap/model/DescribeAgreementStatusResult.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_MSEAP_MODEL_DESCRIBEAGREEMENTSTATUSRESULT_H_
+#define ALIBABACLOUD_MSEAP_MODEL_DESCRIBEAGREEMENTSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mseap/MseapExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mseap
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSEAP_EXPORT DescribeAgreementStatusResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeAgreementStatusResult();
+				explicit DescribeAgreementStatusResult(const std::string &payload);
+				~DescribeAgreementStatusResult();
+				int getStatus()const;
+				std::string getUserId()const;
+				std::string getAgreementCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int status_;
+				std::string userId_;
+				std::string agreementCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSEAP_MODEL_DESCRIBEAGREEMENTSTATUSRESULT_H_

mseap/include/alibabacloud/mseap/model/GenerateUploadFilePolicyForPartnerRequest.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_MSEAP_MODEL_GENERATEUPLOADFILEPOLICYFORPARTNERREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_GENERATEUPLOADFILEPOLICYFORPARTNERREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT GenerateUploadFilePolicyForPartnerRequest : public RpcServiceRequest {
+public:
+	GenerateUploadFilePolicyForPartnerRequest();
+	~GenerateUploadFilePolicyForPartnerRequest();
+	std::string getFileType() const;
+	void setFileType(const std::string &fileType);
+	std::string getBizType() const;
+	void setBizType(const std::string &bizType);
+	std::string getFileName() const;
+	void setFileName(const std::string &fileName);
+
+private:
+	std::string fileType_;
+	std::string bizType_;
+	std::string fileName_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_GENERATEUPLOADFILEPOLICYFORPARTNERREQUEST_H_

mseap/include/alibabacloud/mseap/model/GenerateUploadFilePolicyForPartnerResult.h

@@ -0,0 +1,79 @@
+/*
+ * 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_MSEAP_MODEL_GENERATEUPLOADFILEPOLICYFORPARTNERRESULT_H_
+#define ALIBABACLOUD_MSEAP_MODEL_GENERATEUPLOADFILEPOLICYFORPARTNERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mseap/MseapExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mseap
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSEAP_EXPORT GenerateUploadFilePolicyForPartnerResult : public ServiceResult
+			{
+			public:
+				struct Module
+				{
+					std::string fileDir;
+					std::string encodedPolicy;
+					std::string accessId;
+					std::string signature;
+					std::string ossUrl;
+					std::string host;
+					long expireTime;
+				};
+
+
+				GenerateUploadFilePolicyForPartnerResult();
+				explicit GenerateUploadFilePolicyForPartnerResult(const std::string &payload);
+				~GenerateUploadFilePolicyForPartnerResult();
+				bool getAllowRetry()const;
+				std::vector<std::string> getErrorArgs()const;
+				int getHttpStatusCode()const;
+				std::string getErrorMsg()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getErrorCode()const;
+				Module getModule()const;
+				bool getSuccess()const;
+				std::string getAppName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool allowRetry_;
+				std::vector<std::string> errorArgs_;
+				int httpStatusCode_;
+				std::string errorMsg_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string errorCode_;
+				Module module_;
+				bool success_;
+				std::string appName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSEAP_MODEL_GENERATEUPLOADFILEPOLICYFORPARTNERRESULT_H_

mseap/include/alibabacloud/mseap/model/GetNodeByFlowIdRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_MSEAP_MODEL_GETNODEBYFLOWIDREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_GETNODEBYFLOWIDREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT GetNodeByFlowIdRequest : public RpcServiceRequest {
+public:
+	GetNodeByFlowIdRequest();
+	~GetNodeByFlowIdRequest();
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	bool getUserMfaPresent() const;
+	void setUserMfaPresent(bool userMfaPresent);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	bool getUserCallerSecurityTransport() const;
+	void setUserCallerSecurityTransport(bool userCallerSecurityTransport);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+	long getFlowId() const;
+	void setFlowId(long flowId);
+
+private:
+	long userCallerParentId_;
+	std::string apiType_;
+	bool userMfaPresent_;
+	std::string userKp_;
+	std::string lang_;
+	std::string userCallerType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	bool userCallerSecurityTransport_;
+	std::string userClientIp_;
+	std::string bid_;
+	long flowId_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_GETNODEBYFLOWIDREQUEST_H_

mseap/include/alibabacloud/mseap/model/GetNodeByFlowIdResult.h

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

mseap/include/alibabacloud/mseap/model/GetNodeByTemplateIdRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_MSEAP_MODEL_GETNODEBYTEMPLATEIDREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_GETNODEBYTEMPLATEIDREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT GetNodeByTemplateIdRequest : public RpcServiceRequest {
+public:
+	GetNodeByTemplateIdRequest();
+	~GetNodeByTemplateIdRequest();
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	bool getUserMfaPresent() const;
+	void setUserMfaPresent(bool userMfaPresent);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	long getTemplateId() const;
+	void setTemplateId(long templateId);
+	bool getUserCallerSecurityTransport() const;
+	void setUserCallerSecurityTransport(bool userCallerSecurityTransport);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+
+private:
+	long userCallerParentId_;
+	std::string apiType_;
+	bool userMfaPresent_;
+	std::string userKp_;
+	std::string lang_;
+	std::string userCallerType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	long templateId_;
+	bool userCallerSecurityTransport_;
+	std::string userClientIp_;
+	std::string bid_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_GETNODEBYTEMPLATEIDREQUEST_H_

mseap/include/alibabacloud/mseap/model/GetNodeByTemplateIdResult.h

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

mseap/include/alibabacloud/mseap/model/GetProxyByTypeRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_MSEAP_MODEL_GETPROXYBYTYPEREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_GETPROXYBYTYPEREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT GetProxyByTypeRequest : public RpcServiceRequest {
+public:
+	GetProxyByTypeRequest();
+	~GetProxyByTypeRequest();
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	int getType() const;
+	void setType(int type);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	bool getUserMfaPresent() const;
+	void setUserMfaPresent(bool userMfaPresent);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	bool getUserCallerSecurityTransport() const;
+	void setUserCallerSecurityTransport(bool userCallerSecurityTransport);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+
+private:
+	long userCallerParentId_;
+	int type_;
+	std::string apiType_;
+	bool userMfaPresent_;
+	std::string userKp_;
+	std::string lang_;
+	std::string userCallerType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	bool userCallerSecurityTransport_;
+	std::string userClientIp_;
+	std::string bid_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_GETPROXYBYTYPEREQUEST_H_

mseap/include/alibabacloud/mseap/model/GetProxyByTypeResult.h

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

mseap/include/alibabacloud/mseap/model/GetRedisValueRequest.h

@@ -0,0 +1,90 @@
+/*
+ * 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_MSEAP_MODEL_GETREDISVALUEREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_GETREDISVALUEREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT GetRedisValueRequest : public RpcServiceRequest {
+public:
+	GetRedisValueRequest();
+	~GetRedisValueRequest();
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	long getTimeout() const;
+	void setTimeout(long timeout);
+	bool getUserMfaPresent() const;
+	void setUserMfaPresent(bool userMfaPresent);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	std::string getValue() const;
+	void setValue(const std::string &value);
+	std::string getKey() const;
+	void setKey(const std::string &key);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	bool getUserCallerSecurityTransport() const;
+	void setUserCallerSecurityTransport(bool userCallerSecurityTransport);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+
+private:
+	long userCallerParentId_;
+	std::string apiType_;
+	long timeout_;
+	bool userMfaPresent_;
+	std::string userKp_;
+	std::string lang_;
+	std::string value_;
+	std::string key_;
+	std::string userCallerType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	bool userCallerSecurityTransport_;
+	std::string userClientIp_;
+	std::string bid_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_GETREDISVALUEREQUEST_H_

mseap/include/alibabacloud/mseap/model/GetRedisValueResult.h

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

mseap/include/alibabacloud/mseap/model/GetVariableRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_MSEAP_MODEL_GETVARIABLEREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_GETVARIABLEREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT GetVariableRequest : public RpcServiceRequest {
+public:
+	GetVariableRequest();
+	~GetVariableRequest();
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	bool getUserMfaPresent() const;
+	void setUserMfaPresent(bool userMfaPresent);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	long getTemplateId() const;
+	void setTemplateId(long templateId);
+	bool getUserCallerSecurityTransport() const;
+	void setUserCallerSecurityTransport(bool userCallerSecurityTransport);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+
+private:
+	long userCallerParentId_;
+	std::string apiType_;
+	bool userMfaPresent_;
+	std::string userKp_;
+	std::string lang_;
+	std::string userCallerType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	long templateId_;
+	bool userCallerSecurityTransport_;
+	std::string userClientIp_;
+	std::string bid_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_GETVARIABLEREQUEST_H_

mseap/include/alibabacloud/mseap/model/GetVariableResult.h

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

mseap/include/alibabacloud/mseap/model/IdentifyCodeRequest.h

@@ -0,0 +1,90 @@
+/*
+ * 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_MSEAP_MODEL_IDENTIFYCODEREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_IDENTIFYCODEREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT IdentifyCodeRequest : public RpcServiceRequest {
+public:
+	IdentifyCodeRequest();
+	~IdentifyCodeRequest();
+	std::string getData() const;
+	void setData(const std::string &data);
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	std::string getType() const;
+	void setType(const std::string &type);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	bool getUserMfaPresent() const;
+	void setUserMfaPresent(bool userMfaPresent);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	std::string getLabel() const;
+	void setLabel(const std::string &label);
+	bool getUserCallerSecurityTransport() const;
+	void setUserCallerSecurityTransport(bool userCallerSecurityTransport);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+
+private:
+	std::string data_;
+	long userCallerParentId_;
+	std::string type_;
+	std::string apiType_;
+	bool userMfaPresent_;
+	std::string userKp_;
+	std::string lang_;
+	std::string userCallerType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	std::string label_;
+	bool userCallerSecurityTransport_;
+	std::string userClientIp_;
+	std::string bid_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_IDENTIFYCODEREQUEST_H_

mseap/include/alibabacloud/mseap/model/IdentifyCodeResult.h

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

mseap/include/alibabacloud/mseap/model/PullRpaModelRequest.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSEAP_MODEL_PULLRPAMODELREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_PULLRPAMODELREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT PullRpaModelRequest : public RpcServiceRequest {
+public:
+	PullRpaModelRequest();
+	~PullRpaModelRequest();
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	bool getUserMfaPresent() const;
+	void setUserMfaPresent(bool userMfaPresent);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	long getTemplateId() const;
+	void setTemplateId(long templateId);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+
+private:
+	long userCallerParentId_;
+	std::string apiType_;
+	bool userMfaPresent_;
+	std::string userKp_;
+	std::string lang_;
+	std::string userCallerType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	long templateId_;
+	std::string userClientIp_;
+	std::string bid_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_PULLRPAMODELREQUEST_H_

mseap/include/alibabacloud/mseap/model/PullRpaModelResult.h

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

mseap/include/alibabacloud/mseap/model/PullTaskRequest.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSEAP_MODEL_PULLTASKREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_PULLTASKREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT PullTaskRequest : public RpcServiceRequest {
+public:
+	PullTaskRequest();
+	~PullTaskRequest();
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	bool getUserMfaPresent() const;
+	void setUserMfaPresent(bool userMfaPresent);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getTaskType() const;
+	void setTaskType(const std::string &taskType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	std::string getOrderId() const;
+	void setOrderId(const std::string &orderId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	std::string getPrincipalKey() const;
+	void setPrincipalKey(const std::string &principalKey);
+	bool getUserCallerSecurityTransport() const;
+	void setUserCallerSecurityTransport(bool userCallerSecurityTransport);
+	std::string getBizCode() const;
+	void setBizCode(const std::string &bizCode);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+
+private:
+	long userCallerParentId_;
+	std::string apiType_;
+	bool userMfaPresent_;
+	std::string userKp_;
+	std::string lang_;
+	std::string userCallerType_;
+	std::string taskType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	std::string orderId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	std::string principalKey_;
+	bool userCallerSecurityTransport_;
+	std::string bizCode_;
+	std::string userClientIp_;
+	std::string bid_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_PULLTASKREQUEST_H_

mseap/include/alibabacloud/mseap/model/PullTaskResult.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSEAP_MODEL_PULLTASKRESULT_H_
+#define ALIBABACLOUD_MSEAP_MODEL_PULLTASKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mseap/MseapExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mseap
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSEAP_EXPORT PullTaskResult : public ServiceResult
+			{
+			public:
+				struct Module
+				{
+					std::string outTaskId;
+					std::string taskId;
+					std::string taskType;
+					std::string orderId;
+					std::string principalKey;
+					std::string taskData;
+					std::string bizCode;
+				};
+
+
+				PullTaskResult();
+				explicit PullTaskResult(const std::string &payload);
+				~PullTaskResult();
+				bool getAllowRetry()const;
+				std::string getErrorMsg()const;
+				int getHttpStatusCode()const;
+				std::string getDynamicCode()const;
+				std::string getErrorCode()const;
+				std::string getDynamicMessage()const;
+				Module getModule()const;
+				bool getSuccess()const;
+				std::string getAppName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool allowRetry_;
+				std::string errorMsg_;
+				int httpStatusCode_;
+				std::string dynamicCode_;
+				std::string errorCode_;
+				std::string dynamicMessage_;
+				Module module_;
+				bool success_;
+				std::string appName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSEAP_MODEL_PULLTASKRESULT_H_

mseap/include/alibabacloud/mseap/model/PushRpaTaskDetailRequest.h

@@ -0,0 +1,105 @@
+/*
+ * 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_MSEAP_MODEL_PUSHRPATASKDETAILREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_PUSHRPATASKDETAILREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT PushRpaTaskDetailRequest : public RpcServiceRequest {
+public:
+	PushRpaTaskDetailRequest();
+	~PushRpaTaskDetailRequest();
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	long getModelDetailId() const;
+	void setModelDetailId(long modelDetailId);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	long getTaskId() const;
+	void setTaskId(long taskId);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	std::string getInputScreenshot() const;
+	void setInputScreenshot(const std::string &inputScreenshot);
+	std::string getInputData() const;
+	void setInputData(const std::string &inputData);
+	std::string getOutputData() const;
+	void setOutputData(const std::string &outputData);
+	std::string getInputHtml() const;
+	void setInputHtml(const std::string &inputHtml);
+	long getTaskDetailId() const;
+	void setTaskDetailId(long taskDetailId);
+	std::string getOutputHtml() const;
+	void setOutputHtml(const std::string &outputHtml);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+	std::string getOutputScreenshot() const;
+	void setOutputScreenshot(const std::string &outputScreenshot);
+	int getStatus() const;
+	void setStatus(int status);
+
+private:
+	long userCallerParentId_;
+	std::string apiType_;
+	long modelDetailId_;
+	std::string userKp_;
+	std::string lang_;
+	long taskId_;
+	std::string userCallerType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	std::string inputScreenshot_;
+	std::string inputData_;
+	std::string outputData_;
+	std::string inputHtml_;
+	long taskDetailId_;
+	std::string outputHtml_;
+	std::string userClientIp_;
+	std::string bid_;
+	std::string outputScreenshot_;
+	int status_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_PUSHRPATASKDETAILREQUEST_H_

mseap/include/alibabacloud/mseap/model/PushRpaTaskDetailResult.h

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

mseap/include/alibabacloud/mseap/model/PushRpaTaskRequest.h

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_MSEAP_MODEL_PUSHRPATASKREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_PUSHRPATASKREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT PushRpaTaskRequest : public RpcServiceRequest {
+public:
+	PushRpaTaskRequest();
+	~PushRpaTaskRequest();
+	std::string getRequest() const;
+	void setRequest(const std::string &request);
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	bool getUserMfaPresent() const;
+	void setUserMfaPresent(bool userMfaPresent);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	long getTaskId() const;
+	void setTaskId(long taskId);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	long getModelId() const;
+	void setModelId(long modelId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	long getTemplateId() const;
+	void setTemplateId(long templateId);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+	int getStatus() const;
+	void setStatus(int status);
+
+private:
+	std::string request_;
+	long userCallerParentId_;
+	std::string apiType_;
+	bool userMfaPresent_;
+	std::string userKp_;
+	std::string lang_;
+	long taskId_;
+	std::string userCallerType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	long modelId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	long templateId_;
+	std::string userClientIp_;
+	std::string name_;
+	std::string bid_;
+	int status_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_PUSHRPATASKREQUEST_H_

mseap/include/alibabacloud/mseap/model/PushRpaTaskResult.h

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

mseap/include/alibabacloud/mseap/model/SetRedisValueRequest.h

@@ -0,0 +1,90 @@
+/*
+ * 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_MSEAP_MODEL_SETREDISVALUEREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_SETREDISVALUEREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT SetRedisValueRequest : public RpcServiceRequest {
+public:
+	SetRedisValueRequest();
+	~SetRedisValueRequest();
+	long getUserCallerParentId() const;
+	void setUserCallerParentId(long userCallerParentId);
+	std::string getApiType() const;
+	void setApiType(const std::string &apiType);
+	long getTimeout() const;
+	void setTimeout(long timeout);
+	bool getUserMfaPresent() const;
+	void setUserMfaPresent(bool userMfaPresent);
+	std::string getUserKp() const;
+	void setUserKp(const std::string &userKp);
+	std::string getLang() const;
+	void setLang(const std::string &lang);
+	std::string getValue() const;
+	void setValue(const std::string &value);
+	std::string getKey() const;
+	void setKey(const std::string &key);
+	std::string getUserCallerType() const;
+	void setUserCallerType(const std::string &userCallerType);
+	std::string getUserSecurityToken() const;
+	void setUserSecurityToken(const std::string &userSecurityToken);
+	std::string getUserAccessKeyId() const;
+	void setUserAccessKeyId(const std::string &userAccessKeyId);
+	std::string getAliyunKp() const;
+	void setAliyunKp(const std::string &aliyunKp);
+	std::string getUserBid() const;
+	void setUserBid(const std::string &userBid);
+	std::string getOriginalRequest() const;
+	void setOriginalRequest(const std::string &originalRequest);
+	std::string getRequestId() const;
+	void setRequestId(const std::string &requestId);
+	std::string getUserClientIp() const;
+	void setUserClientIp(const std::string &userClientIp);
+	std::string getBid() const;
+	void setBid(const std::string &bid);
+
+private:
+	long userCallerParentId_;
+	std::string apiType_;
+	long timeout_;
+	bool userMfaPresent_;
+	std::string userKp_;
+	std::string lang_;
+	std::string value_;
+	std::string key_;
+	std::string userCallerType_;
+	std::string userSecurityToken_;
+	std::string userAccessKeyId_;
+	std::string aliyunKp_;
+	std::string userBid_;
+	std::string originalRequest_;
+	std::string requestId_;
+	std::string userClientIp_;
+	std::string bid_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_SETREDISVALUEREQUEST_H_

mseap/include/alibabacloud/mseap/model/SetRedisValueResult.h

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

mseap/include/alibabacloud/mseap/model/UpdateAgreementStatusRequest.h

@@ -0,0 +1,42 @@
+/*
+ * 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_MSEAP_MODEL_UPDATEAGREEMENTSTATUSREQUEST_H_
+#define ALIBABACLOUD_MSEAP_MODEL_UPDATEAGREEMENTSTATUSREQUEST_H_
+
+#include <alibabacloud/mseap/MseapExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Mseap {
+namespace Model {
+class ALIBABACLOUD_MSEAP_EXPORT UpdateAgreementStatusRequest : public RpcServiceRequest {
+public:
+	UpdateAgreementStatusRequest();
+	~UpdateAgreementStatusRequest();
+	std::string getAgreementCode() const;
+	void setAgreementCode(const std::string &agreementCode);
+
+private:
+	std::string agreementCode_;
+};
+} // namespace Model
+} // namespace Mseap
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_MSEAP_MODEL_UPDATEAGREEMENTSTATUSREQUEST_H_

mseap/include/alibabacloud/mseap/model/UpdateAgreementStatusResult.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_MSEAP_MODEL_UPDATEAGREEMENTSTATUSRESULT_H_
+#define ALIBABACLOUD_MSEAP_MODEL_UPDATEAGREEMENTSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/mseap/MseapExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Mseap
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_MSEAP_EXPORT UpdateAgreementStatusResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateAgreementStatusResult();
+				explicit UpdateAgreementStatusResult(const std::string &payload);
+				~UpdateAgreementStatusResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_MSEAP_MODEL_UPDATEAGREEMENTSTATUSRESULT_H_

mseap/src/MseapClient.cc

@@ -0,0 +1,629 @@
+/*
+ * 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/mseap/MseapClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "mseap";
+}
+
+MseapClient::MseapClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	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, "");
+}
+
+MseapClient::MseapClient(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, "");
+}
+
+MseapClient::MseapClient(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, "");
+}
+
+MseapClient::~MseapClient()
+{}
+
+MseapClient::ActivateLicenseOutcome MseapClient::activateLicense(const ActivateLicenseRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ActivateLicenseOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ActivateLicenseOutcome(ActivateLicenseResult(outcome.result()));
+	else
+		return ActivateLicenseOutcome(outcome.error());
+}
+
+void MseapClient::activateLicenseAsync(const ActivateLicenseRequest& request, const ActivateLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, activateLicense(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::ActivateLicenseOutcomeCallable MseapClient::activateLicenseCallable(const ActivateLicenseRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ActivateLicenseOutcome()>>(
+			[this, request]()
+			{
+			return this->activateLicense(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::CallbackTaskOutcome MseapClient::callbackTask(const CallbackTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CallbackTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CallbackTaskOutcome(CallbackTaskResult(outcome.result()));
+	else
+		return CallbackTaskOutcome(outcome.error());
+}
+
+void MseapClient::callbackTaskAsync(const CallbackTaskRequest& request, const CallbackTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, callbackTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::CallbackTaskOutcomeCallable MseapClient::callbackTaskCallable(const CallbackTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CallbackTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->callbackTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::DescribeAgreementStatusOutcome MseapClient::describeAgreementStatus(const DescribeAgreementStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeAgreementStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeAgreementStatusOutcome(DescribeAgreementStatusResult(outcome.result()));
+	else
+		return DescribeAgreementStatusOutcome(outcome.error());
+}
+
+void MseapClient::describeAgreementStatusAsync(const DescribeAgreementStatusRequest& request, const DescribeAgreementStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeAgreementStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::DescribeAgreementStatusOutcomeCallable MseapClient::describeAgreementStatusCallable(const DescribeAgreementStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeAgreementStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->describeAgreementStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::GenerateUploadFilePolicyForPartnerOutcome MseapClient::generateUploadFilePolicyForPartner(const GenerateUploadFilePolicyForPartnerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GenerateUploadFilePolicyForPartnerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GenerateUploadFilePolicyForPartnerOutcome(GenerateUploadFilePolicyForPartnerResult(outcome.result()));
+	else
+		return GenerateUploadFilePolicyForPartnerOutcome(outcome.error());
+}
+
+void MseapClient::generateUploadFilePolicyForPartnerAsync(const GenerateUploadFilePolicyForPartnerRequest& request, const GenerateUploadFilePolicyForPartnerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, generateUploadFilePolicyForPartner(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::GenerateUploadFilePolicyForPartnerOutcomeCallable MseapClient::generateUploadFilePolicyForPartnerCallable(const GenerateUploadFilePolicyForPartnerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GenerateUploadFilePolicyForPartnerOutcome()>>(
+			[this, request]()
+			{
+			return this->generateUploadFilePolicyForPartner(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::GetNodeByFlowIdOutcome MseapClient::getNodeByFlowId(const GetNodeByFlowIdRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetNodeByFlowIdOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetNodeByFlowIdOutcome(GetNodeByFlowIdResult(outcome.result()));
+	else
+		return GetNodeByFlowIdOutcome(outcome.error());
+}
+
+void MseapClient::getNodeByFlowIdAsync(const GetNodeByFlowIdRequest& request, const GetNodeByFlowIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getNodeByFlowId(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::GetNodeByFlowIdOutcomeCallable MseapClient::getNodeByFlowIdCallable(const GetNodeByFlowIdRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetNodeByFlowIdOutcome()>>(
+			[this, request]()
+			{
+			return this->getNodeByFlowId(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::GetNodeByTemplateIdOutcome MseapClient::getNodeByTemplateId(const GetNodeByTemplateIdRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetNodeByTemplateIdOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetNodeByTemplateIdOutcome(GetNodeByTemplateIdResult(outcome.result()));
+	else
+		return GetNodeByTemplateIdOutcome(outcome.error());
+}
+
+void MseapClient::getNodeByTemplateIdAsync(const GetNodeByTemplateIdRequest& request, const GetNodeByTemplateIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getNodeByTemplateId(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::GetNodeByTemplateIdOutcomeCallable MseapClient::getNodeByTemplateIdCallable(const GetNodeByTemplateIdRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetNodeByTemplateIdOutcome()>>(
+			[this, request]()
+			{
+			return this->getNodeByTemplateId(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::GetProxyByTypeOutcome MseapClient::getProxyByType(const GetProxyByTypeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetProxyByTypeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetProxyByTypeOutcome(GetProxyByTypeResult(outcome.result()));
+	else
+		return GetProxyByTypeOutcome(outcome.error());
+}
+
+void MseapClient::getProxyByTypeAsync(const GetProxyByTypeRequest& request, const GetProxyByTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getProxyByType(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::GetProxyByTypeOutcomeCallable MseapClient::getProxyByTypeCallable(const GetProxyByTypeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetProxyByTypeOutcome()>>(
+			[this, request]()
+			{
+			return this->getProxyByType(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::GetRedisValueOutcome MseapClient::getRedisValue(const GetRedisValueRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetRedisValueOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetRedisValueOutcome(GetRedisValueResult(outcome.result()));
+	else
+		return GetRedisValueOutcome(outcome.error());
+}
+
+void MseapClient::getRedisValueAsync(const GetRedisValueRequest& request, const GetRedisValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getRedisValue(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::GetRedisValueOutcomeCallable MseapClient::getRedisValueCallable(const GetRedisValueRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetRedisValueOutcome()>>(
+			[this, request]()
+			{
+			return this->getRedisValue(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::GetVariableOutcome MseapClient::getVariable(const GetVariableRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetVariableOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetVariableOutcome(GetVariableResult(outcome.result()));
+	else
+		return GetVariableOutcome(outcome.error());
+}
+
+void MseapClient::getVariableAsync(const GetVariableRequest& request, const GetVariableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getVariable(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::GetVariableOutcomeCallable MseapClient::getVariableCallable(const GetVariableRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetVariableOutcome()>>(
+			[this, request]()
+			{
+			return this->getVariable(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::IdentifyCodeOutcome MseapClient::identifyCode(const IdentifyCodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return IdentifyCodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return IdentifyCodeOutcome(IdentifyCodeResult(outcome.result()));
+	else
+		return IdentifyCodeOutcome(outcome.error());
+}
+
+void MseapClient::identifyCodeAsync(const IdentifyCodeRequest& request, const IdentifyCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, identifyCode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::IdentifyCodeOutcomeCallable MseapClient::identifyCodeCallable(const IdentifyCodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<IdentifyCodeOutcome()>>(
+			[this, request]()
+			{
+			return this->identifyCode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::PullRpaModelOutcome MseapClient::pullRpaModel(const PullRpaModelRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PullRpaModelOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PullRpaModelOutcome(PullRpaModelResult(outcome.result()));
+	else
+		return PullRpaModelOutcome(outcome.error());
+}
+
+void MseapClient::pullRpaModelAsync(const PullRpaModelRequest& request, const PullRpaModelAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, pullRpaModel(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::PullRpaModelOutcomeCallable MseapClient::pullRpaModelCallable(const PullRpaModelRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PullRpaModelOutcome()>>(
+			[this, request]()
+			{
+			return this->pullRpaModel(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::PullTaskOutcome MseapClient::pullTask(const PullTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PullTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PullTaskOutcome(PullTaskResult(outcome.result()));
+	else
+		return PullTaskOutcome(outcome.error());
+}
+
+void MseapClient::pullTaskAsync(const PullTaskRequest& request, const PullTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, pullTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::PullTaskOutcomeCallable MseapClient::pullTaskCallable(const PullTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PullTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->pullTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::PushRpaTaskOutcome MseapClient::pushRpaTask(const PushRpaTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PushRpaTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PushRpaTaskOutcome(PushRpaTaskResult(outcome.result()));
+	else
+		return PushRpaTaskOutcome(outcome.error());
+}
+
+void MseapClient::pushRpaTaskAsync(const PushRpaTaskRequest& request, const PushRpaTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, pushRpaTask(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::PushRpaTaskOutcomeCallable MseapClient::pushRpaTaskCallable(const PushRpaTaskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PushRpaTaskOutcome()>>(
+			[this, request]()
+			{
+			return this->pushRpaTask(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::PushRpaTaskDetailOutcome MseapClient::pushRpaTaskDetail(const PushRpaTaskDetailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PushRpaTaskDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PushRpaTaskDetailOutcome(PushRpaTaskDetailResult(outcome.result()));
+	else
+		return PushRpaTaskDetailOutcome(outcome.error());
+}
+
+void MseapClient::pushRpaTaskDetailAsync(const PushRpaTaskDetailRequest& request, const PushRpaTaskDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, pushRpaTaskDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::PushRpaTaskDetailOutcomeCallable MseapClient::pushRpaTaskDetailCallable(const PushRpaTaskDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PushRpaTaskDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->pushRpaTaskDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::SetRedisValueOutcome MseapClient::setRedisValue(const SetRedisValueRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetRedisValueOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetRedisValueOutcome(SetRedisValueResult(outcome.result()));
+	else
+		return SetRedisValueOutcome(outcome.error());
+}
+
+void MseapClient::setRedisValueAsync(const SetRedisValueRequest& request, const SetRedisValueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setRedisValue(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::SetRedisValueOutcomeCallable MseapClient::setRedisValueCallable(const SetRedisValueRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetRedisValueOutcome()>>(
+			[this, request]()
+			{
+			return this->setRedisValue(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+MseapClient::UpdateAgreementStatusOutcome MseapClient::updateAgreementStatus(const UpdateAgreementStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateAgreementStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateAgreementStatusOutcome(UpdateAgreementStatusResult(outcome.result()));
+	else
+		return UpdateAgreementStatusOutcome(outcome.error());
+}
+
+void MseapClient::updateAgreementStatusAsync(const UpdateAgreementStatusRequest& request, const UpdateAgreementStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateAgreementStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+MseapClient::UpdateAgreementStatusOutcomeCallable MseapClient::updateAgreementStatusCallable(const UpdateAgreementStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateAgreementStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->updateAgreementStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

mseap/src/model/ActivateLicenseRequest.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/mseap/model/ActivateLicenseRequest.h>
+
+using AlibabaCloud::Mseap::Model::ActivateLicenseRequest;
+
+ActivateLicenseRequest::ActivateLicenseRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "ActivateLicense") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ActivateLicenseRequest::~ActivateLicenseRequest() {}
+
+std::string ActivateLicenseRequest::getLicenseNo() const {
+  return licenseNo_;
+}
+
+void ActivateLicenseRequest::setLicenseNo(const std::string &licenseNo) {
+  licenseNo_ = licenseNo;
+  setParameter(std::string("LicenseNo"), licenseNo);
+}
+
+std::string ActivateLicenseRequest::getBizType() const {
+  return bizType_;
+}
+
+void ActivateLicenseRequest::setBizType(const std::string &bizType) {
+  bizType_ = bizType;
+  setParameter(std::string("BizType"), bizType);
+}
+
+std::string ActivateLicenseRequest::getLicensePublisher() const {
+  return licensePublisher_;
+}
+
+void ActivateLicenseRequest::setLicensePublisher(const std::string &licensePublisher) {
+  licensePublisher_ = licensePublisher;
+  setParameter(std::string("LicensePublisher"), licensePublisher);
+}
+
+std::string ActivateLicenseRequest::getBizId() const {
+  return bizId_;
+}
+
+void ActivateLicenseRequest::setBizId(const std::string &bizId) {
+  bizId_ = bizId;
+  setParameter(std::string("BizId"), bizId);
+}
+
+std::string ActivateLicenseRequest::getLicenseCode() const {
+  return licenseCode_;
+}
+
+void ActivateLicenseRequest::setLicenseCode(const std::string &licenseCode) {
+  licenseCode_ = licenseCode;
+  setParameter(std::string("LicenseCode"), licenseCode);
+}
+

mseap/src/model/ActivateLicenseResult.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/mseap/model/ActivateLicenseResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+ActivateLicenseResult::ActivateLicenseResult() :
+	ServiceResult()
+{}
+
+ActivateLicenseResult::ActivateLicenseResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ActivateLicenseResult::~ActivateLicenseResult()
+{}
+
+void ActivateLicenseResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString() == "true";
+
+}
+
+bool ActivateLicenseResult::getData()const
+{
+	return data_;
+}
+

mseap/src/model/CallbackTaskRequest.cc

@@ -0,0 +1,216 @@
+/*
+ * 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/mseap/model/CallbackTaskRequest.h>
+
+using AlibabaCloud::Mseap::Model::CallbackTaskRequest;
+
+CallbackTaskRequest::CallbackTaskRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "CallbackTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CallbackTaskRequest::~CallbackTaskRequest() {}
+
+long CallbackTaskRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void CallbackTaskRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+std::string CallbackTaskRequest::getOutTaskId() const {
+  return outTaskId_;
+}
+
+void CallbackTaskRequest::setOutTaskId(const std::string &outTaskId) {
+  outTaskId_ = outTaskId;
+  setParameter(std::string("OutTaskId"), outTaskId);
+}
+
+std::string CallbackTaskRequest::getApiType() const {
+  return apiType_;
+}
+
+void CallbackTaskRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+bool CallbackTaskRequest::getUserMfaPresent() const {
+  return userMfaPresent_;
+}
+
+void CallbackTaskRequest::setUserMfaPresent(bool userMfaPresent) {
+  userMfaPresent_ = userMfaPresent;
+  setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
+}
+
+std::string CallbackTaskRequest::getUserKp() const {
+  return userKp_;
+}
+
+void CallbackTaskRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string CallbackTaskRequest::getLang() const {
+  return lang_;
+}
+
+void CallbackTaskRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string CallbackTaskRequest::getTaskId() const {
+  return taskId_;
+}
+
+void CallbackTaskRequest::setTaskId(const std::string &taskId) {
+  taskId_ = taskId;
+  setParameter(std::string("TaskId"), taskId);
+}
+
+std::string CallbackTaskRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void CallbackTaskRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string CallbackTaskRequest::getTaskType() const {
+  return taskType_;
+}
+
+void CallbackTaskRequest::setTaskType(const std::string &taskType) {
+  taskType_ = taskType;
+  setParameter(std::string("TaskType"), taskType);
+}
+
+std::string CallbackTaskRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void CallbackTaskRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string CallbackTaskRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void CallbackTaskRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+std::string CallbackTaskRequest::getOrderId() const {
+  return orderId_;
+}
+
+void CallbackTaskRequest::setOrderId(const std::string &orderId) {
+  orderId_ = orderId;
+  setParameter(std::string("OrderId"), orderId);
+}
+
+std::string CallbackTaskRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void CallbackTaskRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string CallbackTaskRequest::getUserBid() const {
+  return userBid_;
+}
+
+void CallbackTaskRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string CallbackTaskRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void CallbackTaskRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+std::string CallbackTaskRequest::getPrincipalKey() const {
+  return principalKey_;
+}
+
+void CallbackTaskRequest::setPrincipalKey(const std::string &principalKey) {
+  principalKey_ = principalKey;
+  setParameter(std::string("PrincipalKey"), principalKey);
+}
+
+bool CallbackTaskRequest::getUserCallerSecurityTransport() const {
+  return userCallerSecurityTransport_;
+}
+
+void CallbackTaskRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
+  userCallerSecurityTransport_ = userCallerSecurityTransport;
+  setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
+}
+
+std::string CallbackTaskRequest::getBizCode() const {
+  return bizCode_;
+}
+
+void CallbackTaskRequest::setBizCode(const std::string &bizCode) {
+  bizCode_ = bizCode;
+  setParameter(std::string("BizCode"), bizCode);
+}
+
+std::string CallbackTaskRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void CallbackTaskRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string CallbackTaskRequest::getTaskData() const {
+  return taskData_;
+}
+
+void CallbackTaskRequest::setTaskData(const std::string &taskData) {
+  taskData_ = taskData;
+  setParameter(std::string("TaskData"), taskData);
+}
+
+std::string CallbackTaskRequest::getBid() const {
+  return bid_;
+}
+
+void CallbackTaskRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+

mseap/src/model/CallbackTaskResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/mseap/model/CallbackTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+CallbackTaskResult::CallbackTaskResult() :
+	ServiceResult()
+{}
+
+CallbackTaskResult::CallbackTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CallbackTaskResult::~CallbackTaskResult()
+{}
+
+void CallbackTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Module"].isNull())
+		module_ = value["Module"].asString() == "true";
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool CallbackTaskResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string CallbackTaskResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int CallbackTaskResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string CallbackTaskResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string CallbackTaskResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string CallbackTaskResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+bool CallbackTaskResult::getModule()const
+{
+	return module_;
+}
+
+bool CallbackTaskResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string CallbackTaskResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/DescribeAgreementStatusRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * 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/mseap/model/DescribeAgreementStatusRequest.h>
+
+using AlibabaCloud::Mseap::Model::DescribeAgreementStatusRequest;
+
+DescribeAgreementStatusRequest::DescribeAgreementStatusRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "DescribeAgreementStatus") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeAgreementStatusRequest::~DescribeAgreementStatusRequest() {}
+
+std::string DescribeAgreementStatusRequest::getAgreementCode() const {
+  return agreementCode_;
+}
+
+void DescribeAgreementStatusRequest::setAgreementCode(const std::string &agreementCode) {
+  agreementCode_ = agreementCode;
+  setParameter(std::string("AgreementCode"), agreementCode);
+}
+

mseap/src/model/DescribeAgreementStatusResult.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/mseap/model/DescribeAgreementStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+DescribeAgreementStatusResult::DescribeAgreementStatusResult() :
+	ServiceResult()
+{}
+
+DescribeAgreementStatusResult::DescribeAgreementStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeAgreementStatusResult::~DescribeAgreementStatusResult()
+{}
+
+void DescribeAgreementStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Status"].isNull())
+		status_ = std::stoi(value["Status"].asString());
+	if(!value["AgreementCode"].isNull())
+		agreementCode_ = value["AgreementCode"].asString();
+	if(!value["UserId"].isNull())
+		userId_ = value["UserId"].asString();
+
+}
+
+int DescribeAgreementStatusResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeAgreementStatusResult::getUserId()const
+{
+	return userId_;
+}
+
+std::string DescribeAgreementStatusResult::getAgreementCode()const
+{
+	return agreementCode_;
+}
+

mseap/src/model/GenerateUploadFilePolicyForPartnerRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/mseap/model/GenerateUploadFilePolicyForPartnerRequest.h>
+
+using AlibabaCloud::Mseap::Model::GenerateUploadFilePolicyForPartnerRequest;
+
+GenerateUploadFilePolicyForPartnerRequest::GenerateUploadFilePolicyForPartnerRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "GenerateUploadFilePolicyForPartner") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GenerateUploadFilePolicyForPartnerRequest::~GenerateUploadFilePolicyForPartnerRequest() {}
+
+std::string GenerateUploadFilePolicyForPartnerRequest::getFileType() const {
+  return fileType_;
+}
+
+void GenerateUploadFilePolicyForPartnerRequest::setFileType(const std::string &fileType) {
+  fileType_ = fileType;
+  setParameter(std::string("FileType"), fileType);
+}
+
+std::string GenerateUploadFilePolicyForPartnerRequest::getBizType() const {
+  return bizType_;
+}
+
+void GenerateUploadFilePolicyForPartnerRequest::setBizType(const std::string &bizType) {
+  bizType_ = bizType;
+  setParameter(std::string("BizType"), bizType);
+}
+
+std::string GenerateUploadFilePolicyForPartnerRequest::getFileName() const {
+  return fileName_;
+}
+
+void GenerateUploadFilePolicyForPartnerRequest::setFileName(const std::string &fileName) {
+  fileName_ = fileName;
+  setParameter(std::string("FileName"), fileName);
+}
+

mseap/src/model/GenerateUploadFilePolicyForPartnerResult.cc

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/mseap/model/GenerateUploadFilePolicyForPartnerResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+GenerateUploadFilePolicyForPartnerResult::GenerateUploadFilePolicyForPartnerResult() :
+	ServiceResult()
+{}
+
+GenerateUploadFilePolicyForPartnerResult::GenerateUploadFilePolicyForPartnerResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GenerateUploadFilePolicyForPartnerResult::~GenerateUploadFilePolicyForPartnerResult()
+{}
+
+void GenerateUploadFilePolicyForPartnerResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto moduleNode = value["Module"];
+	if(!moduleNode["AccessId"].isNull())
+		module_.accessId = moduleNode["AccessId"].asString();
+	if(!moduleNode["EncodedPolicy"].isNull())
+		module_.encodedPolicy = moduleNode["EncodedPolicy"].asString();
+	if(!moduleNode["Signature"].isNull())
+		module_.signature = moduleNode["Signature"].asString();
+	if(!moduleNode["FileDir"].isNull())
+		module_.fileDir = moduleNode["FileDir"].asString();
+	if(!moduleNode["Host"].isNull())
+		module_.host = moduleNode["Host"].asString();
+	if(!moduleNode["ExpireTime"].isNull())
+		module_.expireTime = std::stol(moduleNode["ExpireTime"].asString());
+	if(!moduleNode["OssUrl"].isNull())
+		module_.ossUrl = moduleNode["OssUrl"].asString();
+	auto allErrorArgs = value["ErrorArgs"]["ErrorArg"];
+	for (const auto &item : allErrorArgs)
+		errorArgs_.push_back(item.asString());
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool GenerateUploadFilePolicyForPartnerResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::vector<std::string> GenerateUploadFilePolicyForPartnerResult::getErrorArgs()const
+{
+	return errorArgs_;
+}
+
+int GenerateUploadFilePolicyForPartnerResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string GenerateUploadFilePolicyForPartnerResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+std::string GenerateUploadFilePolicyForPartnerResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string GenerateUploadFilePolicyForPartnerResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string GenerateUploadFilePolicyForPartnerResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+GenerateUploadFilePolicyForPartnerResult::Module GenerateUploadFilePolicyForPartnerResult::getModule()const
+{
+	return module_;
+}
+
+bool GenerateUploadFilePolicyForPartnerResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string GenerateUploadFilePolicyForPartnerResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/GetNodeByFlowIdRequest.cc

@@ -0,0 +1,162 @@
+/*
+ * 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/mseap/model/GetNodeByFlowIdRequest.h>
+
+using AlibabaCloud::Mseap::Model::GetNodeByFlowIdRequest;
+
+GetNodeByFlowIdRequest::GetNodeByFlowIdRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "GetNodeByFlowId") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetNodeByFlowIdRequest::~GetNodeByFlowIdRequest() {}
+
+long GetNodeByFlowIdRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void GetNodeByFlowIdRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+std::string GetNodeByFlowIdRequest::getApiType() const {
+  return apiType_;
+}
+
+void GetNodeByFlowIdRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+bool GetNodeByFlowIdRequest::getUserMfaPresent() const {
+  return userMfaPresent_;
+}
+
+void GetNodeByFlowIdRequest::setUserMfaPresent(bool userMfaPresent) {
+  userMfaPresent_ = userMfaPresent;
+  setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
+}
+
+std::string GetNodeByFlowIdRequest::getUserKp() const {
+  return userKp_;
+}
+
+void GetNodeByFlowIdRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string GetNodeByFlowIdRequest::getLang() const {
+  return lang_;
+}
+
+void GetNodeByFlowIdRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string GetNodeByFlowIdRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void GetNodeByFlowIdRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string GetNodeByFlowIdRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void GetNodeByFlowIdRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string GetNodeByFlowIdRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void GetNodeByFlowIdRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+std::string GetNodeByFlowIdRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void GetNodeByFlowIdRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string GetNodeByFlowIdRequest::getUserBid() const {
+  return userBid_;
+}
+
+void GetNodeByFlowIdRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string GetNodeByFlowIdRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void GetNodeByFlowIdRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+bool GetNodeByFlowIdRequest::getUserCallerSecurityTransport() const {
+  return userCallerSecurityTransport_;
+}
+
+void GetNodeByFlowIdRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
+  userCallerSecurityTransport_ = userCallerSecurityTransport;
+  setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
+}
+
+std::string GetNodeByFlowIdRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void GetNodeByFlowIdRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string GetNodeByFlowIdRequest::getBid() const {
+  return bid_;
+}
+
+void GetNodeByFlowIdRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+
+long GetNodeByFlowIdRequest::getFlowId() const {
+  return flowId_;
+}
+
+void GetNodeByFlowIdRequest::setFlowId(long flowId) {
+  flowId_ = flowId;
+  setParameter(std::string("FlowId"), std::to_string(flowId));
+}
+

mseap/src/model/GetNodeByFlowIdResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/mseap/model/GetNodeByFlowIdResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+GetNodeByFlowIdResult::GetNodeByFlowIdResult() :
+	ServiceResult()
+{}
+
+GetNodeByFlowIdResult::GetNodeByFlowIdResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetNodeByFlowIdResult::~GetNodeByFlowIdResult()
+{}
+
+void GetNodeByFlowIdResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Module"].isNull())
+		module_ = value["Module"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool GetNodeByFlowIdResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string GetNodeByFlowIdResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int GetNodeByFlowIdResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string GetNodeByFlowIdResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string GetNodeByFlowIdResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string GetNodeByFlowIdResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string GetNodeByFlowIdResult::getModule()const
+{
+	return module_;
+}
+
+bool GetNodeByFlowIdResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string GetNodeByFlowIdResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/GetNodeByTemplateIdRequest.cc

@@ -0,0 +1,162 @@
+/*
+ * 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/mseap/model/GetNodeByTemplateIdRequest.h>
+
+using AlibabaCloud::Mseap::Model::GetNodeByTemplateIdRequest;
+
+GetNodeByTemplateIdRequest::GetNodeByTemplateIdRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "GetNodeByTemplateId") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetNodeByTemplateIdRequest::~GetNodeByTemplateIdRequest() {}
+
+long GetNodeByTemplateIdRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void GetNodeByTemplateIdRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+std::string GetNodeByTemplateIdRequest::getApiType() const {
+  return apiType_;
+}
+
+void GetNodeByTemplateIdRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+bool GetNodeByTemplateIdRequest::getUserMfaPresent() const {
+  return userMfaPresent_;
+}
+
+void GetNodeByTemplateIdRequest::setUserMfaPresent(bool userMfaPresent) {
+  userMfaPresent_ = userMfaPresent;
+  setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
+}
+
+std::string GetNodeByTemplateIdRequest::getUserKp() const {
+  return userKp_;
+}
+
+void GetNodeByTemplateIdRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string GetNodeByTemplateIdRequest::getLang() const {
+  return lang_;
+}
+
+void GetNodeByTemplateIdRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string GetNodeByTemplateIdRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void GetNodeByTemplateIdRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string GetNodeByTemplateIdRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void GetNodeByTemplateIdRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string GetNodeByTemplateIdRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void GetNodeByTemplateIdRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+std::string GetNodeByTemplateIdRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void GetNodeByTemplateIdRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string GetNodeByTemplateIdRequest::getUserBid() const {
+  return userBid_;
+}
+
+void GetNodeByTemplateIdRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string GetNodeByTemplateIdRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void GetNodeByTemplateIdRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+long GetNodeByTemplateIdRequest::getTemplateId() const {
+  return templateId_;
+}
+
+void GetNodeByTemplateIdRequest::setTemplateId(long templateId) {
+  templateId_ = templateId;
+  setParameter(std::string("TemplateId"), std::to_string(templateId));
+}
+
+bool GetNodeByTemplateIdRequest::getUserCallerSecurityTransport() const {
+  return userCallerSecurityTransport_;
+}
+
+void GetNodeByTemplateIdRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
+  userCallerSecurityTransport_ = userCallerSecurityTransport;
+  setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
+}
+
+std::string GetNodeByTemplateIdRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void GetNodeByTemplateIdRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string GetNodeByTemplateIdRequest::getBid() const {
+  return bid_;
+}
+
+void GetNodeByTemplateIdRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+

mseap/src/model/GetNodeByTemplateIdResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/mseap/model/GetNodeByTemplateIdResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+GetNodeByTemplateIdResult::GetNodeByTemplateIdResult() :
+	ServiceResult()
+{}
+
+GetNodeByTemplateIdResult::GetNodeByTemplateIdResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetNodeByTemplateIdResult::~GetNodeByTemplateIdResult()
+{}
+
+void GetNodeByTemplateIdResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Module"].isNull())
+		module_ = value["Module"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool GetNodeByTemplateIdResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string GetNodeByTemplateIdResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int GetNodeByTemplateIdResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string GetNodeByTemplateIdResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string GetNodeByTemplateIdResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string GetNodeByTemplateIdResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string GetNodeByTemplateIdResult::getModule()const
+{
+	return module_;
+}
+
+bool GetNodeByTemplateIdResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string GetNodeByTemplateIdResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/GetProxyByTypeRequest.cc

@@ -0,0 +1,162 @@
+/*
+ * 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/mseap/model/GetProxyByTypeRequest.h>
+
+using AlibabaCloud::Mseap::Model::GetProxyByTypeRequest;
+
+GetProxyByTypeRequest::GetProxyByTypeRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "GetProxyByType") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetProxyByTypeRequest::~GetProxyByTypeRequest() {}
+
+long GetProxyByTypeRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void GetProxyByTypeRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+int GetProxyByTypeRequest::getType() const {
+  return type_;
+}
+
+void GetProxyByTypeRequest::setType(int type) {
+  type_ = type;
+  setParameter(std::string("Type"), std::to_string(type));
+}
+
+std::string GetProxyByTypeRequest::getApiType() const {
+  return apiType_;
+}
+
+void GetProxyByTypeRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+bool GetProxyByTypeRequest::getUserMfaPresent() const {
+  return userMfaPresent_;
+}
+
+void GetProxyByTypeRequest::setUserMfaPresent(bool userMfaPresent) {
+  userMfaPresent_ = userMfaPresent;
+  setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
+}
+
+std::string GetProxyByTypeRequest::getUserKp() const {
+  return userKp_;
+}
+
+void GetProxyByTypeRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string GetProxyByTypeRequest::getLang() const {
+  return lang_;
+}
+
+void GetProxyByTypeRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string GetProxyByTypeRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void GetProxyByTypeRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string GetProxyByTypeRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void GetProxyByTypeRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string GetProxyByTypeRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void GetProxyByTypeRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+std::string GetProxyByTypeRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void GetProxyByTypeRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string GetProxyByTypeRequest::getUserBid() const {
+  return userBid_;
+}
+
+void GetProxyByTypeRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string GetProxyByTypeRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void GetProxyByTypeRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+bool GetProxyByTypeRequest::getUserCallerSecurityTransport() const {
+  return userCallerSecurityTransport_;
+}
+
+void GetProxyByTypeRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
+  userCallerSecurityTransport_ = userCallerSecurityTransport;
+  setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
+}
+
+std::string GetProxyByTypeRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void GetProxyByTypeRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string GetProxyByTypeRequest::getBid() const {
+  return bid_;
+}
+
+void GetProxyByTypeRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+

mseap/src/model/GetProxyByTypeResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/mseap/model/GetProxyByTypeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+GetProxyByTypeResult::GetProxyByTypeResult() :
+	ServiceResult()
+{}
+
+GetProxyByTypeResult::GetProxyByTypeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetProxyByTypeResult::~GetProxyByTypeResult()
+{}
+
+void GetProxyByTypeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Module"].isNull())
+		module_ = value["Module"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool GetProxyByTypeResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string GetProxyByTypeResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int GetProxyByTypeResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string GetProxyByTypeResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string GetProxyByTypeResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string GetProxyByTypeResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string GetProxyByTypeResult::getModule()const
+{
+	return module_;
+}
+
+bool GetProxyByTypeResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string GetProxyByTypeResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/GetRedisValueRequest.cc

@@ -0,0 +1,180 @@
+/*
+ * 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/mseap/model/GetRedisValueRequest.h>
+
+using AlibabaCloud::Mseap::Model::GetRedisValueRequest;
+
+GetRedisValueRequest::GetRedisValueRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "GetRedisValue") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetRedisValueRequest::~GetRedisValueRequest() {}
+
+long GetRedisValueRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void GetRedisValueRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+std::string GetRedisValueRequest::getApiType() const {
+  return apiType_;
+}
+
+void GetRedisValueRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+long GetRedisValueRequest::getTimeout() const {
+  return timeout_;
+}
+
+void GetRedisValueRequest::setTimeout(long timeout) {
+  timeout_ = timeout;
+  setParameter(std::string("Timeout"), std::to_string(timeout));
+}
+
+bool GetRedisValueRequest::getUserMfaPresent() const {
+  return userMfaPresent_;
+}
+
+void GetRedisValueRequest::setUserMfaPresent(bool userMfaPresent) {
+  userMfaPresent_ = userMfaPresent;
+  setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
+}
+
+std::string GetRedisValueRequest::getUserKp() const {
+  return userKp_;
+}
+
+void GetRedisValueRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string GetRedisValueRequest::getLang() const {
+  return lang_;
+}
+
+void GetRedisValueRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string GetRedisValueRequest::getValue() const {
+  return value_;
+}
+
+void GetRedisValueRequest::setValue(const std::string &value) {
+  value_ = value;
+  setParameter(std::string("Value"), value);
+}
+
+std::string GetRedisValueRequest::getKey() const {
+  return key_;
+}
+
+void GetRedisValueRequest::setKey(const std::string &key) {
+  key_ = key;
+  setParameter(std::string("Key"), key);
+}
+
+std::string GetRedisValueRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void GetRedisValueRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string GetRedisValueRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void GetRedisValueRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string GetRedisValueRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void GetRedisValueRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+std::string GetRedisValueRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void GetRedisValueRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string GetRedisValueRequest::getUserBid() const {
+  return userBid_;
+}
+
+void GetRedisValueRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string GetRedisValueRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void GetRedisValueRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+bool GetRedisValueRequest::getUserCallerSecurityTransport() const {
+  return userCallerSecurityTransport_;
+}
+
+void GetRedisValueRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
+  userCallerSecurityTransport_ = userCallerSecurityTransport;
+  setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
+}
+
+std::string GetRedisValueRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void GetRedisValueRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string GetRedisValueRequest::getBid() const {
+  return bid_;
+}
+
+void GetRedisValueRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+

mseap/src/model/GetRedisValueResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/mseap/model/GetRedisValueResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+GetRedisValueResult::GetRedisValueResult() :
+	ServiceResult()
+{}
+
+GetRedisValueResult::GetRedisValueResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetRedisValueResult::~GetRedisValueResult()
+{}
+
+void GetRedisValueResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Module"].isNull())
+		module_ = value["Module"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool GetRedisValueResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string GetRedisValueResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int GetRedisValueResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string GetRedisValueResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string GetRedisValueResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string GetRedisValueResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string GetRedisValueResult::getModule()const
+{
+	return module_;
+}
+
+bool GetRedisValueResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string GetRedisValueResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/GetVariableRequest.cc

@@ -0,0 +1,162 @@
+/*
+ * 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/mseap/model/GetVariableRequest.h>
+
+using AlibabaCloud::Mseap::Model::GetVariableRequest;
+
+GetVariableRequest::GetVariableRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "GetVariable") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetVariableRequest::~GetVariableRequest() {}
+
+long GetVariableRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void GetVariableRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+std::string GetVariableRequest::getApiType() const {
+  return apiType_;
+}
+
+void GetVariableRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+bool GetVariableRequest::getUserMfaPresent() const {
+  return userMfaPresent_;
+}
+
+void GetVariableRequest::setUserMfaPresent(bool userMfaPresent) {
+  userMfaPresent_ = userMfaPresent;
+  setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
+}
+
+std::string GetVariableRequest::getUserKp() const {
+  return userKp_;
+}
+
+void GetVariableRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string GetVariableRequest::getLang() const {
+  return lang_;
+}
+
+void GetVariableRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string GetVariableRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void GetVariableRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string GetVariableRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void GetVariableRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string GetVariableRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void GetVariableRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+std::string GetVariableRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void GetVariableRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string GetVariableRequest::getUserBid() const {
+  return userBid_;
+}
+
+void GetVariableRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string GetVariableRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void GetVariableRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+long GetVariableRequest::getTemplateId() const {
+  return templateId_;
+}
+
+void GetVariableRequest::setTemplateId(long templateId) {
+  templateId_ = templateId;
+  setParameter(std::string("TemplateId"), std::to_string(templateId));
+}
+
+bool GetVariableRequest::getUserCallerSecurityTransport() const {
+  return userCallerSecurityTransport_;
+}
+
+void GetVariableRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
+  userCallerSecurityTransport_ = userCallerSecurityTransport;
+  setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
+}
+
+std::string GetVariableRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void GetVariableRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string GetVariableRequest::getBid() const {
+  return bid_;
+}
+
+void GetVariableRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+

mseap/src/model/GetVariableResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/mseap/model/GetVariableResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+GetVariableResult::GetVariableResult() :
+	ServiceResult()
+{}
+
+GetVariableResult::GetVariableResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetVariableResult::~GetVariableResult()
+{}
+
+void GetVariableResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Module"].isNull())
+		module_ = value["Module"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool GetVariableResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string GetVariableResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int GetVariableResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string GetVariableResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string GetVariableResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string GetVariableResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string GetVariableResult::getModule()const
+{
+	return module_;
+}
+
+bool GetVariableResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string GetVariableResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/IdentifyCodeRequest.cc

@@ -0,0 +1,180 @@
+/*
+ * 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/mseap/model/IdentifyCodeRequest.h>
+
+using AlibabaCloud::Mseap::Model::IdentifyCodeRequest;
+
+IdentifyCodeRequest::IdentifyCodeRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "IdentifyCode") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+IdentifyCodeRequest::~IdentifyCodeRequest() {}
+
+std::string IdentifyCodeRequest::getData() const {
+  return data_;
+}
+
+void IdentifyCodeRequest::setData(const std::string &data) {
+  data_ = data;
+  setParameter(std::string("Data"), data);
+}
+
+long IdentifyCodeRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void IdentifyCodeRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+std::string IdentifyCodeRequest::getType() const {
+  return type_;
+}
+
+void IdentifyCodeRequest::setType(const std::string &type) {
+  type_ = type;
+  setParameter(std::string("Type"), type);
+}
+
+std::string IdentifyCodeRequest::getApiType() const {
+  return apiType_;
+}
+
+void IdentifyCodeRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+bool IdentifyCodeRequest::getUserMfaPresent() const {
+  return userMfaPresent_;
+}
+
+void IdentifyCodeRequest::setUserMfaPresent(bool userMfaPresent) {
+  userMfaPresent_ = userMfaPresent;
+  setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
+}
+
+std::string IdentifyCodeRequest::getUserKp() const {
+  return userKp_;
+}
+
+void IdentifyCodeRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string IdentifyCodeRequest::getLang() const {
+  return lang_;
+}
+
+void IdentifyCodeRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string IdentifyCodeRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void IdentifyCodeRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string IdentifyCodeRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void IdentifyCodeRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string IdentifyCodeRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void IdentifyCodeRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+std::string IdentifyCodeRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void IdentifyCodeRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string IdentifyCodeRequest::getUserBid() const {
+  return userBid_;
+}
+
+void IdentifyCodeRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string IdentifyCodeRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void IdentifyCodeRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+std::string IdentifyCodeRequest::getLabel() const {
+  return label_;
+}
+
+void IdentifyCodeRequest::setLabel(const std::string &label) {
+  label_ = label;
+  setParameter(std::string("Label"), label);
+}
+
+bool IdentifyCodeRequest::getUserCallerSecurityTransport() const {
+  return userCallerSecurityTransport_;
+}
+
+void IdentifyCodeRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
+  userCallerSecurityTransport_ = userCallerSecurityTransport;
+  setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
+}
+
+std::string IdentifyCodeRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void IdentifyCodeRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string IdentifyCodeRequest::getBid() const {
+  return bid_;
+}
+
+void IdentifyCodeRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+

mseap/src/model/IdentifyCodeResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/mseap/model/IdentifyCodeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+IdentifyCodeResult::IdentifyCodeResult() :
+	ServiceResult()
+{}
+
+IdentifyCodeResult::IdentifyCodeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+IdentifyCodeResult::~IdentifyCodeResult()
+{}
+
+void IdentifyCodeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Module"].isNull())
+		module_ = value["Module"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool IdentifyCodeResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string IdentifyCodeResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int IdentifyCodeResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string IdentifyCodeResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string IdentifyCodeResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string IdentifyCodeResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string IdentifyCodeResult::getModule()const
+{
+	return module_;
+}
+
+bool IdentifyCodeResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string IdentifyCodeResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/PullRpaModelRequest.cc

@@ -0,0 +1,153 @@
+/*
+ * 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/mseap/model/PullRpaModelRequest.h>
+
+using AlibabaCloud::Mseap::Model::PullRpaModelRequest;
+
+PullRpaModelRequest::PullRpaModelRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "PullRpaModel") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+PullRpaModelRequest::~PullRpaModelRequest() {}
+
+long PullRpaModelRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void PullRpaModelRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+std::string PullRpaModelRequest::getApiType() const {
+  return apiType_;
+}
+
+void PullRpaModelRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+bool PullRpaModelRequest::getUserMfaPresent() const {
+  return userMfaPresent_;
+}
+
+void PullRpaModelRequest::setUserMfaPresent(bool userMfaPresent) {
+  userMfaPresent_ = userMfaPresent;
+  setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
+}
+
+std::string PullRpaModelRequest::getUserKp() const {
+  return userKp_;
+}
+
+void PullRpaModelRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string PullRpaModelRequest::getLang() const {
+  return lang_;
+}
+
+void PullRpaModelRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string PullRpaModelRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void PullRpaModelRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string PullRpaModelRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void PullRpaModelRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string PullRpaModelRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void PullRpaModelRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+std::string PullRpaModelRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void PullRpaModelRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string PullRpaModelRequest::getUserBid() const {
+  return userBid_;
+}
+
+void PullRpaModelRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string PullRpaModelRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void PullRpaModelRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+long PullRpaModelRequest::getTemplateId() const {
+  return templateId_;
+}
+
+void PullRpaModelRequest::setTemplateId(long templateId) {
+  templateId_ = templateId;
+  setParameter(std::string("TemplateId"), std::to_string(templateId));
+}
+
+std::string PullRpaModelRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void PullRpaModelRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string PullRpaModelRequest::getBid() const {
+  return bid_;
+}
+
+void PullRpaModelRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+

mseap/src/model/PullRpaModelResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/mseap/model/PullRpaModelResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+PullRpaModelResult::PullRpaModelResult() :
+	ServiceResult()
+{}
+
+PullRpaModelResult::PullRpaModelResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PullRpaModelResult::~PullRpaModelResult()
+{}
+
+void PullRpaModelResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Module"].isNull())
+		module_ = value["Module"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool PullRpaModelResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string PullRpaModelResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int PullRpaModelResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string PullRpaModelResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string PullRpaModelResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string PullRpaModelResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string PullRpaModelResult::getModule()const
+{
+	return module_;
+}
+
+bool PullRpaModelResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string PullRpaModelResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/PullTaskRequest.cc

@@ -0,0 +1,189 @@
+/*
+ * 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/mseap/model/PullTaskRequest.h>
+
+using AlibabaCloud::Mseap::Model::PullTaskRequest;
+
+PullTaskRequest::PullTaskRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "PullTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+PullTaskRequest::~PullTaskRequest() {}
+
+long PullTaskRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void PullTaskRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+std::string PullTaskRequest::getApiType() const {
+  return apiType_;
+}
+
+void PullTaskRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+bool PullTaskRequest::getUserMfaPresent() const {
+  return userMfaPresent_;
+}
+
+void PullTaskRequest::setUserMfaPresent(bool userMfaPresent) {
+  userMfaPresent_ = userMfaPresent;
+  setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
+}
+
+std::string PullTaskRequest::getUserKp() const {
+  return userKp_;
+}
+
+void PullTaskRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string PullTaskRequest::getLang() const {
+  return lang_;
+}
+
+void PullTaskRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string PullTaskRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void PullTaskRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string PullTaskRequest::getTaskType() const {
+  return taskType_;
+}
+
+void PullTaskRequest::setTaskType(const std::string &taskType) {
+  taskType_ = taskType;
+  setParameter(std::string("TaskType"), taskType);
+}
+
+std::string PullTaskRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void PullTaskRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string PullTaskRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void PullTaskRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+std::string PullTaskRequest::getOrderId() const {
+  return orderId_;
+}
+
+void PullTaskRequest::setOrderId(const std::string &orderId) {
+  orderId_ = orderId;
+  setParameter(std::string("OrderId"), orderId);
+}
+
+std::string PullTaskRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void PullTaskRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string PullTaskRequest::getUserBid() const {
+  return userBid_;
+}
+
+void PullTaskRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string PullTaskRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void PullTaskRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+std::string PullTaskRequest::getPrincipalKey() const {
+  return principalKey_;
+}
+
+void PullTaskRequest::setPrincipalKey(const std::string &principalKey) {
+  principalKey_ = principalKey;
+  setParameter(std::string("PrincipalKey"), principalKey);
+}
+
+bool PullTaskRequest::getUserCallerSecurityTransport() const {
+  return userCallerSecurityTransport_;
+}
+
+void PullTaskRequest::setUserCallerSecurityTransport(bool userCallerSecurityTransport) {
+  userCallerSecurityTransport_ = userCallerSecurityTransport;
+  setParameter(std::string("UserCallerSecurityTransport"), userCallerSecurityTransport ? "true" : "false");
+}
+
+std::string PullTaskRequest::getBizCode() const {
+  return bizCode_;
+}
+
+void PullTaskRequest::setBizCode(const std::string &bizCode) {
+  bizCode_ = bizCode;
+  setParameter(std::string("BizCode"), bizCode);
+}
+
+std::string PullTaskRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void PullTaskRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string PullTaskRequest::getBid() const {
+  return bid_;
+}
+
+void PullTaskRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+

mseap/src/model/PullTaskResult.cc

@@ -0,0 +1,120 @@
+/*
+ * 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/mseap/model/PullTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+PullTaskResult::PullTaskResult() :
+	ServiceResult()
+{}
+
+PullTaskResult::PullTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PullTaskResult::~PullTaskResult()
+{}
+
+void PullTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto moduleNode = value["Module"];
+	if(!moduleNode["TaskId"].isNull())
+		module_.taskId = moduleNode["TaskId"].asString();
+	if(!moduleNode["OutTaskId"].isNull())
+		module_.outTaskId = moduleNode["OutTaskId"].asString();
+	if(!moduleNode["TaskType"].isNull())
+		module_.taskType = moduleNode["TaskType"].asString();
+	if(!moduleNode["TaskData"].isNull())
+		module_.taskData = moduleNode["TaskData"].asString();
+	if(!moduleNode["OrderId"].isNull())
+		module_.orderId = moduleNode["OrderId"].asString();
+	if(!moduleNode["BizCode"].isNull())
+		module_.bizCode = moduleNode["BizCode"].asString();
+	if(!moduleNode["PrincipalKey"].isNull())
+		module_.principalKey = moduleNode["PrincipalKey"].asString();
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool PullTaskResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string PullTaskResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int PullTaskResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string PullTaskResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string PullTaskResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string PullTaskResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+PullTaskResult::Module PullTaskResult::getModule()const
+{
+	return module_;
+}
+
+bool PullTaskResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string PullTaskResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/PushRpaTaskDetailRequest.cc

@@ -0,0 +1,225 @@
+/*
+ * 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/mseap/model/PushRpaTaskDetailRequest.h>
+
+using AlibabaCloud::Mseap::Model::PushRpaTaskDetailRequest;
+
+PushRpaTaskDetailRequest::PushRpaTaskDetailRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "PushRpaTaskDetail") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+PushRpaTaskDetailRequest::~PushRpaTaskDetailRequest() {}
+
+long PushRpaTaskDetailRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void PushRpaTaskDetailRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+std::string PushRpaTaskDetailRequest::getApiType() const {
+  return apiType_;
+}
+
+void PushRpaTaskDetailRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+long PushRpaTaskDetailRequest::getModelDetailId() const {
+  return modelDetailId_;
+}
+
+void PushRpaTaskDetailRequest::setModelDetailId(long modelDetailId) {
+  modelDetailId_ = modelDetailId;
+  setParameter(std::string("ModelDetailId"), std::to_string(modelDetailId));
+}
+
+std::string PushRpaTaskDetailRequest::getUserKp() const {
+  return userKp_;
+}
+
+void PushRpaTaskDetailRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string PushRpaTaskDetailRequest::getLang() const {
+  return lang_;
+}
+
+void PushRpaTaskDetailRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+long PushRpaTaskDetailRequest::getTaskId() const {
+  return taskId_;
+}
+
+void PushRpaTaskDetailRequest::setTaskId(long taskId) {
+  taskId_ = taskId;
+  setParameter(std::string("TaskId"), std::to_string(taskId));
+}
+
+std::string PushRpaTaskDetailRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void PushRpaTaskDetailRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string PushRpaTaskDetailRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void PushRpaTaskDetailRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string PushRpaTaskDetailRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void PushRpaTaskDetailRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+std::string PushRpaTaskDetailRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void PushRpaTaskDetailRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string PushRpaTaskDetailRequest::getUserBid() const {
+  return userBid_;
+}
+
+void PushRpaTaskDetailRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string PushRpaTaskDetailRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void PushRpaTaskDetailRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+std::string PushRpaTaskDetailRequest::getInputScreenshot() const {
+  return inputScreenshot_;
+}
+
+void PushRpaTaskDetailRequest::setInputScreenshot(const std::string &inputScreenshot) {
+  inputScreenshot_ = inputScreenshot;
+  setParameter(std::string("InputScreenshot"), inputScreenshot);
+}
+
+std::string PushRpaTaskDetailRequest::getInputData() const {
+  return inputData_;
+}
+
+void PushRpaTaskDetailRequest::setInputData(const std::string &inputData) {
+  inputData_ = inputData;
+  setParameter(std::string("InputData"), inputData);
+}
+
+std::string PushRpaTaskDetailRequest::getOutputData() const {
+  return outputData_;
+}
+
+void PushRpaTaskDetailRequest::setOutputData(const std::string &outputData) {
+  outputData_ = outputData;
+  setParameter(std::string("OutputData"), outputData);
+}
+
+std::string PushRpaTaskDetailRequest::getInputHtml() const {
+  return inputHtml_;
+}
+
+void PushRpaTaskDetailRequest::setInputHtml(const std::string &inputHtml) {
+  inputHtml_ = inputHtml;
+  setParameter(std::string("InputHtml"), inputHtml);
+}
+
+long PushRpaTaskDetailRequest::getTaskDetailId() const {
+  return taskDetailId_;
+}
+
+void PushRpaTaskDetailRequest::setTaskDetailId(long taskDetailId) {
+  taskDetailId_ = taskDetailId;
+  setParameter(std::string("TaskDetailId"), std::to_string(taskDetailId));
+}
+
+std::string PushRpaTaskDetailRequest::getOutputHtml() const {
+  return outputHtml_;
+}
+
+void PushRpaTaskDetailRequest::setOutputHtml(const std::string &outputHtml) {
+  outputHtml_ = outputHtml;
+  setParameter(std::string("OutputHtml"), outputHtml);
+}
+
+std::string PushRpaTaskDetailRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void PushRpaTaskDetailRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string PushRpaTaskDetailRequest::getBid() const {
+  return bid_;
+}
+
+void PushRpaTaskDetailRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+
+std::string PushRpaTaskDetailRequest::getOutputScreenshot() const {
+  return outputScreenshot_;
+}
+
+void PushRpaTaskDetailRequest::setOutputScreenshot(const std::string &outputScreenshot) {
+  outputScreenshot_ = outputScreenshot;
+  setParameter(std::string("OutputScreenshot"), outputScreenshot);
+}
+
+int PushRpaTaskDetailRequest::getStatus() const {
+  return status_;
+}
+
+void PushRpaTaskDetailRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
+}
+

mseap/src/model/PushRpaTaskDetailResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/mseap/model/PushRpaTaskDetailResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+PushRpaTaskDetailResult::PushRpaTaskDetailResult() :
+	ServiceResult()
+{}
+
+PushRpaTaskDetailResult::PushRpaTaskDetailResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PushRpaTaskDetailResult::~PushRpaTaskDetailResult()
+{}
+
+void PushRpaTaskDetailResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Module"].isNull())
+		module_ = value["Module"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool PushRpaTaskDetailResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string PushRpaTaskDetailResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int PushRpaTaskDetailResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string PushRpaTaskDetailResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string PushRpaTaskDetailResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string PushRpaTaskDetailResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string PushRpaTaskDetailResult::getModule()const
+{
+	return module_;
+}
+
+bool PushRpaTaskDetailResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string PushRpaTaskDetailResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/PushRpaTaskRequest.cc

@@ -0,0 +1,198 @@
+/*
+ * 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/mseap/model/PushRpaTaskRequest.h>
+
+using AlibabaCloud::Mseap::Model::PushRpaTaskRequest;
+
+PushRpaTaskRequest::PushRpaTaskRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "PushRpaTask") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+PushRpaTaskRequest::~PushRpaTaskRequest() {}
+
+std::string PushRpaTaskRequest::getRequest() const {
+  return request_;
+}
+
+void PushRpaTaskRequest::setRequest(const std::string &request) {
+  request_ = request;
+  setParameter(std::string("Request"), request);
+}
+
+long PushRpaTaskRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void PushRpaTaskRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+std::string PushRpaTaskRequest::getApiType() const {
+  return apiType_;
+}
+
+void PushRpaTaskRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+bool PushRpaTaskRequest::getUserMfaPresent() const {
+  return userMfaPresent_;
+}
+
+void PushRpaTaskRequest::setUserMfaPresent(bool userMfaPresent) {
+  userMfaPresent_ = userMfaPresent;
+  setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
+}
+
+std::string PushRpaTaskRequest::getUserKp() const {
+  return userKp_;
+}
+
+void PushRpaTaskRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string PushRpaTaskRequest::getLang() const {
+  return lang_;
+}
+
+void PushRpaTaskRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+long PushRpaTaskRequest::getTaskId() const {
+  return taskId_;
+}
+
+void PushRpaTaskRequest::setTaskId(long taskId) {
+  taskId_ = taskId;
+  setParameter(std::string("TaskId"), std::to_string(taskId));
+}
+
+std::string PushRpaTaskRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void PushRpaTaskRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string PushRpaTaskRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void PushRpaTaskRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string PushRpaTaskRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void PushRpaTaskRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+long PushRpaTaskRequest::getModelId() const {
+  return modelId_;
+}
+
+void PushRpaTaskRequest::setModelId(long modelId) {
+  modelId_ = modelId;
+  setParameter(std::string("ModelId"), std::to_string(modelId));
+}
+
+std::string PushRpaTaskRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void PushRpaTaskRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string PushRpaTaskRequest::getUserBid() const {
+  return userBid_;
+}
+
+void PushRpaTaskRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string PushRpaTaskRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void PushRpaTaskRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+long PushRpaTaskRequest::getTemplateId() const {
+  return templateId_;
+}
+
+void PushRpaTaskRequest::setTemplateId(long templateId) {
+  templateId_ = templateId;
+  setParameter(std::string("TemplateId"), std::to_string(templateId));
+}
+
+std::string PushRpaTaskRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void PushRpaTaskRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string PushRpaTaskRequest::getName() const {
+  return name_;
+}
+
+void PushRpaTaskRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string PushRpaTaskRequest::getBid() const {
+  return bid_;
+}
+
+void PushRpaTaskRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+
+int PushRpaTaskRequest::getStatus() const {
+  return status_;
+}
+
+void PushRpaTaskRequest::setStatus(int status) {
+  status_ = status;
+  setParameter(std::string("Status"), std::to_string(status));
+}
+

mseap/src/model/PushRpaTaskResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/mseap/model/PushRpaTaskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+PushRpaTaskResult::PushRpaTaskResult() :
+	ServiceResult()
+{}
+
+PushRpaTaskResult::PushRpaTaskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PushRpaTaskResult::~PushRpaTaskResult()
+{}
+
+void PushRpaTaskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Module"].isNull())
+		module_ = value["Module"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool PushRpaTaskResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string PushRpaTaskResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int PushRpaTaskResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string PushRpaTaskResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string PushRpaTaskResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string PushRpaTaskResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string PushRpaTaskResult::getModule()const
+{
+	return module_;
+}
+
+bool PushRpaTaskResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string PushRpaTaskResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/SetRedisValueRequest.cc

@@ -0,0 +1,180 @@
+/*
+ * 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/mseap/model/SetRedisValueRequest.h>
+
+using AlibabaCloud::Mseap::Model::SetRedisValueRequest;
+
+SetRedisValueRequest::SetRedisValueRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "SetRedisValue") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SetRedisValueRequest::~SetRedisValueRequest() {}
+
+long SetRedisValueRequest::getUserCallerParentId() const {
+  return userCallerParentId_;
+}
+
+void SetRedisValueRequest::setUserCallerParentId(long userCallerParentId) {
+  userCallerParentId_ = userCallerParentId;
+  setParameter(std::string("UserCallerParentId"), std::to_string(userCallerParentId));
+}
+
+std::string SetRedisValueRequest::getApiType() const {
+  return apiType_;
+}
+
+void SetRedisValueRequest::setApiType(const std::string &apiType) {
+  apiType_ = apiType;
+  setParameter(std::string("ApiType"), apiType);
+}
+
+long SetRedisValueRequest::getTimeout() const {
+  return timeout_;
+}
+
+void SetRedisValueRequest::setTimeout(long timeout) {
+  timeout_ = timeout;
+  setParameter(std::string("Timeout"), std::to_string(timeout));
+}
+
+bool SetRedisValueRequest::getUserMfaPresent() const {
+  return userMfaPresent_;
+}
+
+void SetRedisValueRequest::setUserMfaPresent(bool userMfaPresent) {
+  userMfaPresent_ = userMfaPresent;
+  setParameter(std::string("UserMfaPresent"), userMfaPresent ? "true" : "false");
+}
+
+std::string SetRedisValueRequest::getUserKp() const {
+  return userKp_;
+}
+
+void SetRedisValueRequest::setUserKp(const std::string &userKp) {
+  userKp_ = userKp;
+  setParameter(std::string("UserKp"), userKp);
+}
+
+std::string SetRedisValueRequest::getLang() const {
+  return lang_;
+}
+
+void SetRedisValueRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string SetRedisValueRequest::getValue() const {
+  return value_;
+}
+
+void SetRedisValueRequest::setValue(const std::string &value) {
+  value_ = value;
+  setParameter(std::string("Value"), value);
+}
+
+std::string SetRedisValueRequest::getKey() const {
+  return key_;
+}
+
+void SetRedisValueRequest::setKey(const std::string &key) {
+  key_ = key;
+  setParameter(std::string("Key"), key);
+}
+
+std::string SetRedisValueRequest::getUserCallerType() const {
+  return userCallerType_;
+}
+
+void SetRedisValueRequest::setUserCallerType(const std::string &userCallerType) {
+  userCallerType_ = userCallerType;
+  setParameter(std::string("UserCallerType"), userCallerType);
+}
+
+std::string SetRedisValueRequest::getUserSecurityToken() const {
+  return userSecurityToken_;
+}
+
+void SetRedisValueRequest::setUserSecurityToken(const std::string &userSecurityToken) {
+  userSecurityToken_ = userSecurityToken;
+  setParameter(std::string("UserSecurityToken"), userSecurityToken);
+}
+
+std::string SetRedisValueRequest::getUserAccessKeyId() const {
+  return userAccessKeyId_;
+}
+
+void SetRedisValueRequest::setUserAccessKeyId(const std::string &userAccessKeyId) {
+  userAccessKeyId_ = userAccessKeyId;
+  setParameter(std::string("UserAccessKeyId"), userAccessKeyId);
+}
+
+std::string SetRedisValueRequest::getAliyunKp() const {
+  return aliyunKp_;
+}
+
+void SetRedisValueRequest::setAliyunKp(const std::string &aliyunKp) {
+  aliyunKp_ = aliyunKp;
+  setParameter(std::string("AliyunKp"), aliyunKp);
+}
+
+std::string SetRedisValueRequest::getUserBid() const {
+  return userBid_;
+}
+
+void SetRedisValueRequest::setUserBid(const std::string &userBid) {
+  userBid_ = userBid;
+  setParameter(std::string("UserBid"), userBid);
+}
+
+std::string SetRedisValueRequest::getOriginalRequest() const {
+  return originalRequest_;
+}
+
+void SetRedisValueRequest::setOriginalRequest(const std::string &originalRequest) {
+  originalRequest_ = originalRequest;
+  setParameter(std::string("OriginalRequest"), originalRequest);
+}
+
+std::string SetRedisValueRequest::getRequestId() const {
+  return requestId_;
+}
+
+void SetRedisValueRequest::setRequestId(const std::string &requestId) {
+  requestId_ = requestId;
+  setParameter(std::string("RequestId"), requestId);
+}
+
+std::string SetRedisValueRequest::getUserClientIp() const {
+  return userClientIp_;
+}
+
+void SetRedisValueRequest::setUserClientIp(const std::string &userClientIp) {
+  userClientIp_ = userClientIp;
+  setParameter(std::string("UserClientIp"), userClientIp);
+}
+
+std::string SetRedisValueRequest::getBid() const {
+  return bid_;
+}
+
+void SetRedisValueRequest::setBid(const std::string &bid) {
+  bid_ = bid;
+  setParameter(std::string("Bid"), bid);
+}
+

mseap/src/model/SetRedisValueResult.cc

@@ -0,0 +1,107 @@
+/*
+ * 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/mseap/model/SetRedisValueResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Mseap;
+using namespace AlibabaCloud::Mseap::Model;
+
+SetRedisValueResult::SetRedisValueResult() :
+	ServiceResult()
+{}
+
+SetRedisValueResult::SetRedisValueResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetRedisValueResult::~SetRedisValueResult()
+{}
+
+void SetRedisValueResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AllowRetry"].isNull())
+		allowRetry_ = value["AllowRetry"].asString() == "true";
+	if(!value["ErrorMsg"].isNull())
+		errorMsg_ = value["ErrorMsg"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["Module"].isNull())
+		module_ = value["Module"].asString() == "true";
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["AppName"].isNull())
+		appName_ = value["AppName"].asString();
+
+}
+
+bool SetRedisValueResult::getAllowRetry()const
+{
+	return allowRetry_;
+}
+
+std::string SetRedisValueResult::getErrorMsg()const
+{
+	return errorMsg_;
+}
+
+int SetRedisValueResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string SetRedisValueResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string SetRedisValueResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string SetRedisValueResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+bool SetRedisValueResult::getModule()const
+{
+	return module_;
+}
+
+bool SetRedisValueResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string SetRedisValueResult::getAppName()const
+{
+	return appName_;
+}
+

mseap/src/model/UpdateAgreementStatusRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * 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/mseap/model/UpdateAgreementStatusRequest.h>
+
+using AlibabaCloud::Mseap::Model::UpdateAgreementStatusRequest;
+
+UpdateAgreementStatusRequest::UpdateAgreementStatusRequest()
+    : RpcServiceRequest("mseap", "2021-01-18", "UpdateAgreementStatus") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateAgreementStatusRequest::~UpdateAgreementStatusRequest() {}
+
+std::string UpdateAgreementStatusRequest::getAgreementCode() const {
+  return agreementCode_;
+}
+
+void UpdateAgreementStatusRequest::setAgreementCode(const std::string &agreementCode) {
+  agreementCode_ = agreementCode;
+  setParameter(std::string("AgreementCode"), agreementCode);
+}
+

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