Add ModifyInstanceProperties.

VERSION

@@ -1 +1 @@
-1.36.2016
+1.36.2041

aimath/CMakeLists.txt

@@ -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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(aimath_public_header 
+	include/alibabacloud/aimath/AIMathClient.h
+	include/alibabacloud/aimath/AIMathExport.h )
+
+set(aimath_public_header_model 
+	include/alibabacloud/aimath/model/GenAnalysisRequest.h
+	include/alibabacloud/aimath/model/GenAnalysisResult.h
+	include/alibabacloud/aimath/model/GenStepRequest.h
+	include/alibabacloud/aimath/model/GenStepResult.h
+	include/alibabacloud/aimath/model/GlobalConfirmRequest.h
+	include/alibabacloud/aimath/model/GlobalConfirmResult.h
+	include/alibabacloud/aimath/model/UpdateAnalysisRequest.h
+	include/alibabacloud/aimath/model/UpdateAnalysisResult.h
+	include/alibabacloud/aimath/model/UpdateStepRequest.h
+	include/alibabacloud/aimath/model/UpdateStepResult.h )
+
+set(aimath_src 
+	src/AIMathClient.cc
+	src/model/GenAnalysisRequest.cc
+	src/model/GenAnalysisResult.cc
+	src/model/GenStepRequest.cc
+	src/model/GenStepResult.cc
+	src/model/GlobalConfirmRequest.cc
+	src/model/GlobalConfirmResult.cc
+	src/model/UpdateAnalysisRequest.cc
+	src/model/UpdateAnalysisResult.cc
+	src/model/UpdateStepRequest.cc
+	src/model/UpdateStepResult.cc )
+
+add_library(aimath ${LIB_TYPE}
+	${aimath_public_header}
+	${aimath_public_header_model}
+	${aimath_src})
+
+set_target_properties(aimath
+	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}aimath
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(aimath
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_AIMATH_LIBRARY)
+endif()
+
+target_include_directories(aimath
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(aimath
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(aimath
+		jsoncpp)
+	target_include_directories(aimath
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(aimath
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(aimath
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(aimath
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(aimath
+		jsoncpp)
+endif()
+
+install(FILES ${aimath_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/aimath)
+install(FILES ${aimath_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/aimath/model)
+install(TARGETS aimath
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

aimath/include/alibabacloud/aimath/AIMathClient.h

@@ -0,0 +1,86 @@
+/*
+ * 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_AIMATH_AIMATHCLIENT_H_
+#define ALIBABACLOUD_AIMATH_AIMATHCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "AIMathExport.h"
+#include "model/GenAnalysisRequest.h"
+#include "model/GenAnalysisResult.h"
+#include "model/GenStepRequest.h"
+#include "model/GenStepResult.h"
+#include "model/GlobalConfirmRequest.h"
+#include "model/GlobalConfirmResult.h"
+#include "model/UpdateAnalysisRequest.h"
+#include "model/UpdateAnalysisResult.h"
+#include "model/UpdateStepRequest.h"
+#include "model/UpdateStepResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace AIMath
+	{
+		class ALIBABACLOUD_AIMATH_EXPORT AIMathClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::GenAnalysisResult> GenAnalysisOutcome;
+			typedef std::future<GenAnalysisOutcome> GenAnalysisOutcomeCallable;
+			typedef std::function<void(const AIMathClient*, const Model::GenAnalysisRequest&, const GenAnalysisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenAnalysisAsyncHandler;
+			typedef Outcome<Error, Model::GenStepResult> GenStepOutcome;
+			typedef std::future<GenStepOutcome> GenStepOutcomeCallable;
+			typedef std::function<void(const AIMathClient*, const Model::GenStepRequest&, const GenStepOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GenStepAsyncHandler;
+			typedef Outcome<Error, Model::GlobalConfirmResult> GlobalConfirmOutcome;
+			typedef std::future<GlobalConfirmOutcome> GlobalConfirmOutcomeCallable;
+			typedef std::function<void(const AIMathClient*, const Model::GlobalConfirmRequest&, const GlobalConfirmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GlobalConfirmAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAnalysisResult> UpdateAnalysisOutcome;
+			typedef std::future<UpdateAnalysisOutcome> UpdateAnalysisOutcomeCallable;
+			typedef std::function<void(const AIMathClient*, const Model::UpdateAnalysisRequest&, const UpdateAnalysisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAnalysisAsyncHandler;
+			typedef Outcome<Error, Model::UpdateStepResult> UpdateStepOutcome;
+			typedef std::future<UpdateStepOutcome> UpdateStepOutcomeCallable;
+			typedef std::function<void(const AIMathClient*, const Model::UpdateStepRequest&, const UpdateStepOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateStepAsyncHandler;
+
+			AIMathClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			AIMathClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			AIMathClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~AIMathClient();
+			GenAnalysisOutcome genAnalysis(const Model::GenAnalysisRequest &request)const;
+			void genAnalysisAsync(const Model::GenAnalysisRequest& request, const GenAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenAnalysisOutcomeCallable genAnalysisCallable(const Model::GenAnalysisRequest& request) const;
+			GenStepOutcome genStep(const Model::GenStepRequest &request)const;
+			void genStepAsync(const Model::GenStepRequest& request, const GenStepAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GenStepOutcomeCallable genStepCallable(const Model::GenStepRequest& request) const;
+			GlobalConfirmOutcome globalConfirm(const Model::GlobalConfirmRequest &request)const;
+			void globalConfirmAsync(const Model::GlobalConfirmRequest& request, const GlobalConfirmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GlobalConfirmOutcomeCallable globalConfirmCallable(const Model::GlobalConfirmRequest& request) const;
+			UpdateAnalysisOutcome updateAnalysis(const Model::UpdateAnalysisRequest &request)const;
+			void updateAnalysisAsync(const Model::UpdateAnalysisRequest& request, const UpdateAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAnalysisOutcomeCallable updateAnalysisCallable(const Model::UpdateAnalysisRequest& request) const;
+			UpdateStepOutcome updateStep(const Model::UpdateStepRequest &request)const;
+			void updateStepAsync(const Model::UpdateStepRequest& request, const UpdateStepAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateStepOutcomeCallable updateStepCallable(const Model::UpdateStepRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_AIMATH_AIMATHCLIENT_H_

aimath/include/alibabacloud/aimath/AIMathExport.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_AIMATH_AIMATHEXPORT_H_
+#define ALIBABACLOUD_AIMATH_AIMATHEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_AIMATH_LIBRARY)
+#		define ALIBABACLOUD_AIMATH_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_AIMATH_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_AIMATH_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_AIMATH_AIMATHEXPORT_H_

aimath/include/alibabacloud/aimath/model/GenAnalysisRequest.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_AIMATH_MODEL_GENANALYSISREQUEST_H_
+#define ALIBABACLOUD_AIMATH_MODEL_GENANALYSISREQUEST_H_
+
+#include <alibabacloud/aimath/AIMathExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIMath {
+namespace Model {
+class ALIBABACLOUD_AIMATH_EXPORT GenAnalysisRequest : public RpcServiceRequest {
+public:
+	GenAnalysisRequest();
+	~GenAnalysisRequest();
+	std::string getExerciseContent() const;
+	void setExerciseContent(const std::string &exerciseContent);
+
+private:
+	std::string exerciseContent_;
+};
+} // namespace Model
+} // namespace AIMath
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIMATH_MODEL_GENANALYSISREQUEST_H_

aimath/include/alibabacloud/aimath/model/GenAnalysisResult.h

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

aimath/include/alibabacloud/aimath/model/GenStepRequest.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_AIMATH_MODEL_GENSTEPREQUEST_H_
+#define ALIBABACLOUD_AIMATH_MODEL_GENSTEPREQUEST_H_
+
+#include <alibabacloud/aimath/AIMathExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIMath {
+namespace Model {
+class ALIBABACLOUD_AIMATH_EXPORT GenStepRequest : public RpcServiceRequest {
+public:
+	GenStepRequest();
+	~GenStepRequest();
+	std::string getExerciseCode() const;
+	void setExerciseCode(const std::string &exerciseCode);
+
+private:
+	std::string exerciseCode_;
+};
+} // namespace Model
+} // namespace AIMath
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIMATH_MODEL_GENSTEPREQUEST_H_

aimath/include/alibabacloud/aimath/model/GenStepResult.h

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

aimath/include/alibabacloud/aimath/model/GlobalConfirmRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_AIMATH_MODEL_GLOBALCONFIRMREQUEST_H_
+#define ALIBABACLOUD_AIMATH_MODEL_GLOBALCONFIRMREQUEST_H_
+
+#include <alibabacloud/aimath/AIMathExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIMath {
+namespace Model {
+class ALIBABACLOUD_AIMATH_EXPORT GlobalConfirmRequest : public RpcServiceRequest {
+public:
+	GlobalConfirmRequest();
+	~GlobalConfirmRequest();
+	std::string getTag() const;
+	void setTag(const std::string &tag);
+	std::string getExerciseCode() const;
+	void setExerciseCode(const std::string &exerciseCode);
+
+private:
+	std::string tag_;
+	std::string exerciseCode_;
+};
+} // namespace Model
+} // namespace AIMath
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIMATH_MODEL_GLOBALCONFIRMREQUEST_H_

aimath/include/alibabacloud/aimath/model/GlobalConfirmResult.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_AIMATH_MODEL_GLOBALCONFIRMRESULT_H_
+#define ALIBABACLOUD_AIMATH_MODEL_GLOBALCONFIRMRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/aimath/AIMathExport.h>
+
+namespace AlibabaCloud
+{
+	namespace AIMath
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AIMATH_EXPORT GlobalConfirmResult : public ServiceResult
+			{
+			public:
+
+
+				GlobalConfirmResult();
+				explicit GlobalConfirmResult(const std::string &payload);
+				~GlobalConfirmResult();
+				std::string getErrMsg()const;
+				bool getSuccess()const;
+				std::string getErrCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errMsg_;
+				bool success_;
+				std::string errCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_AIMATH_MODEL_GLOBALCONFIRMRESULT_H_

aimath/include/alibabacloud/aimath/model/UpdateAnalysisRequest.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_AIMATH_MODEL_UPDATEANALYSISREQUEST_H_
+#define ALIBABACLOUD_AIMATH_MODEL_UPDATEANALYSISREQUEST_H_
+
+#include <alibabacloud/aimath/AIMathExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIMath {
+namespace Model {
+class ALIBABACLOUD_AIMATH_EXPORT UpdateAnalysisRequest : public RpcServiceRequest {
+public:
+	UpdateAnalysisRequest();
+	~UpdateAnalysisRequest();
+	std::string getContent() const;
+	void setContent(const std::string &content);
+	std::string getContentCode() const;
+	void setContentCode(const std::string &contentCode);
+	std::string getExerciseCode() const;
+	void setExerciseCode(const std::string &exerciseCode);
+
+private:
+	std::string content_;
+	std::string contentCode_;
+	std::string exerciseCode_;
+};
+} // namespace Model
+} // namespace AIMath
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIMATH_MODEL_UPDATEANALYSISREQUEST_H_

aimath/include/alibabacloud/aimath/model/UpdateAnalysisResult.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_AIMATH_MODEL_UPDATEANALYSISRESULT_H_
+#define ALIBABACLOUD_AIMATH_MODEL_UPDATEANALYSISRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/aimath/AIMathExport.h>
+
+namespace AlibabaCloud
+{
+	namespace AIMath
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AIMATH_EXPORT UpdateAnalysisResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateAnalysisResult();
+				explicit UpdateAnalysisResult(const std::string &payload);
+				~UpdateAnalysisResult();
+				std::string getErrMsg()const;
+				bool getSuccess()const;
+				std::string getErrCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errMsg_;
+				bool success_;
+				std::string errCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_AIMATH_MODEL_UPDATEANALYSISRESULT_H_

aimath/include/alibabacloud/aimath/model/UpdateStepRequest.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_AIMATH_MODEL_UPDATESTEPREQUEST_H_
+#define ALIBABACLOUD_AIMATH_MODEL_UPDATESTEPREQUEST_H_
+
+#include <alibabacloud/aimath/AIMathExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace AIMath {
+namespace Model {
+class ALIBABACLOUD_AIMATH_EXPORT UpdateStepRequest : public RpcServiceRequest {
+public:
+	UpdateStepRequest();
+	~UpdateStepRequest();
+	std::string getContent() const;
+	void setContent(const std::string &content);
+	std::string getContentCode() const;
+	void setContentCode(const std::string &contentCode);
+	std::string getExerciseCode() const;
+	void setExerciseCode(const std::string &exerciseCode);
+
+private:
+	std::string content_;
+	std::string contentCode_;
+	std::string exerciseCode_;
+};
+} // namespace Model
+} // namespace AIMath
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_AIMATH_MODEL_UPDATESTEPREQUEST_H_

aimath/include/alibabacloud/aimath/model/UpdateStepResult.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_AIMATH_MODEL_UPDATESTEPRESULT_H_
+#define ALIBABACLOUD_AIMATH_MODEL_UPDATESTEPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/aimath/AIMathExport.h>
+
+namespace AlibabaCloud
+{
+	namespace AIMath
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_AIMATH_EXPORT UpdateStepResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateStepResult();
+				explicit UpdateStepResult(const std::string &payload);
+				~UpdateStepResult();
+				std::string getErrMsg()const;
+				bool getSuccess()const;
+				std::string getErrCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errMsg_;
+				bool success_;
+				std::string errCode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_AIMATH_MODEL_UPDATESTEPRESULT_H_

aimath/src/AIMathClient.cc

@@ -0,0 +1,233 @@
+/*
+ * 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/aimath/AIMathClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::AIMath;
+using namespace AlibabaCloud::AIMath::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "AIMath";
+}
+
+AIMathClient::AIMathClient(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, "");
+}
+
+AIMathClient::AIMathClient(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, "");
+}
+
+AIMathClient::AIMathClient(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, "");
+}
+
+AIMathClient::~AIMathClient()
+{}
+
+AIMathClient::GenAnalysisOutcome AIMathClient::genAnalysis(const GenAnalysisRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GenAnalysisOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GenAnalysisOutcome(GenAnalysisResult(outcome.result()));
+	else
+		return GenAnalysisOutcome(outcome.error());
+}
+
+void AIMathClient::genAnalysisAsync(const GenAnalysisRequest& request, const GenAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, genAnalysis(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIMathClient::GenAnalysisOutcomeCallable AIMathClient::genAnalysisCallable(const GenAnalysisRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GenAnalysisOutcome()>>(
+			[this, request]()
+			{
+			return this->genAnalysis(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AIMathClient::GenStepOutcome AIMathClient::genStep(const GenStepRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GenStepOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GenStepOutcome(GenStepResult(outcome.result()));
+	else
+		return GenStepOutcome(outcome.error());
+}
+
+void AIMathClient::genStepAsync(const GenStepRequest& request, const GenStepAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, genStep(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIMathClient::GenStepOutcomeCallable AIMathClient::genStepCallable(const GenStepRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GenStepOutcome()>>(
+			[this, request]()
+			{
+			return this->genStep(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AIMathClient::GlobalConfirmOutcome AIMathClient::globalConfirm(const GlobalConfirmRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GlobalConfirmOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GlobalConfirmOutcome(GlobalConfirmResult(outcome.result()));
+	else
+		return GlobalConfirmOutcome(outcome.error());
+}
+
+void AIMathClient::globalConfirmAsync(const GlobalConfirmRequest& request, const GlobalConfirmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, globalConfirm(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIMathClient::GlobalConfirmOutcomeCallable AIMathClient::globalConfirmCallable(const GlobalConfirmRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GlobalConfirmOutcome()>>(
+			[this, request]()
+			{
+			return this->globalConfirm(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AIMathClient::UpdateAnalysisOutcome AIMathClient::updateAnalysis(const UpdateAnalysisRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateAnalysisOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateAnalysisOutcome(UpdateAnalysisResult(outcome.result()));
+	else
+		return UpdateAnalysisOutcome(outcome.error());
+}
+
+void AIMathClient::updateAnalysisAsync(const UpdateAnalysisRequest& request, const UpdateAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateAnalysis(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIMathClient::UpdateAnalysisOutcomeCallable AIMathClient::updateAnalysisCallable(const UpdateAnalysisRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateAnalysisOutcome()>>(
+			[this, request]()
+			{
+			return this->updateAnalysis(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AIMathClient::UpdateStepOutcome AIMathClient::updateStep(const UpdateStepRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateStepOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateStepOutcome(UpdateStepResult(outcome.result()));
+	else
+		return UpdateStepOutcome(outcome.error());
+}
+
+void AIMathClient::updateStepAsync(const UpdateStepRequest& request, const UpdateStepAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateStep(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AIMathClient::UpdateStepOutcomeCallable AIMathClient::updateStepCallable(const UpdateStepRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateStepOutcome()>>(
+			[this, request]()
+			{
+			return this->updateStep(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

aimath/src/model/GenAnalysisRequest.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/aimath/model/GenAnalysisRequest.h>
+
+using AlibabaCloud::AIMath::Model::GenAnalysisRequest;
+
+GenAnalysisRequest::GenAnalysisRequest()
+    : RpcServiceRequest("aimath", "2024-11-14", "GenAnalysis") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GenAnalysisRequest::~GenAnalysisRequest() {}
+
+std::string GenAnalysisRequest::getExerciseContent() const {
+  return exerciseContent_;
+}
+
+void GenAnalysisRequest::setExerciseContent(const std::string &exerciseContent) {
+  exerciseContent_ = exerciseContent;
+  setBodyParameter(std::string("ExerciseContent"), exerciseContent);
+}
+

aimath/src/model/GenAnalysisResult.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/aimath/model/GenAnalysisResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::AIMath;
+using namespace AlibabaCloud::AIMath::Model;
+
+GenAnalysisResult::GenAnalysisResult() :
+	ServiceResult()
+{}
+
+GenAnalysisResult::GenAnalysisResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GenAnalysisResult::~GenAnalysisResult()
+{}
+
+void GenAnalysisResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["EventType"].isNull())
+		eventType_ = value["EventType"].asString();
+	if(!value["Content"].isNull())
+		content_ = value["Content"].asString();
+	if(!value["ErrCode"].isNull())
+		errCode_ = value["ErrCode"].asString();
+	if(!value["ErrMsg"].isNull())
+		errMsg_ = value["ErrMsg"].asString();
+
+}
+
+std::string GenAnalysisResult::getEventType()const
+{
+	return eventType_;
+}
+
+std::string GenAnalysisResult::getErrMsg()const
+{
+	return errMsg_;
+}
+
+std::string GenAnalysisResult::getContent()const
+{
+	return content_;
+}
+
+std::string GenAnalysisResult::getErrCode()const
+{
+	return errCode_;
+}
+

aimath/src/model/GenStepRequest.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/aimath/model/GenStepRequest.h>
+
+using AlibabaCloud::AIMath::Model::GenStepRequest;
+
+GenStepRequest::GenStepRequest()
+    : RpcServiceRequest("aimath", "2024-11-14", "GenStep") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GenStepRequest::~GenStepRequest() {}
+
+std::string GenStepRequest::getExerciseCode() const {
+  return exerciseCode_;
+}
+
+void GenStepRequest::setExerciseCode(const std::string &exerciseCode) {
+  exerciseCode_ = exerciseCode;
+  setBodyParameter(std::string("ExerciseCode"), exerciseCode);
+}
+

aimath/src/model/GenStepResult.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/aimath/model/GenStepResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::AIMath;
+using namespace AlibabaCloud::AIMath::Model;
+
+GenStepResult::GenStepResult() :
+	ServiceResult()
+{}
+
+GenStepResult::GenStepResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GenStepResult::~GenStepResult()
+{}
+
+void GenStepResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["EventType"].isNull())
+		eventType_ = value["EventType"].asString();
+	if(!value["Content"].isNull())
+		content_ = value["Content"].asString();
+	if(!value["ErrCode"].isNull())
+		errCode_ = value["ErrCode"].asString();
+	if(!value["ErrMsg"].isNull())
+		errMsg_ = value["ErrMsg"].asString();
+
+}
+
+std::string GenStepResult::getEventType()const
+{
+	return eventType_;
+}
+
+std::string GenStepResult::getErrMsg()const
+{
+	return errMsg_;
+}
+
+std::string GenStepResult::getContent()const
+{
+	return content_;
+}
+
+std::string GenStepResult::getErrCode()const
+{
+	return errCode_;
+}
+

aimath/src/model/GlobalConfirmRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/aimath/model/GlobalConfirmRequest.h>
+
+using AlibabaCloud::AIMath::Model::GlobalConfirmRequest;
+
+GlobalConfirmRequest::GlobalConfirmRequest()
+    : RpcServiceRequest("aimath", "2024-11-14", "GlobalConfirm") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GlobalConfirmRequest::~GlobalConfirmRequest() {}
+
+std::string GlobalConfirmRequest::getTag() const {
+  return tag_;
+}
+
+void GlobalConfirmRequest::setTag(const std::string &tag) {
+  tag_ = tag;
+  setBodyParameter(std::string("Tag"), tag);
+}
+
+std::string GlobalConfirmRequest::getExerciseCode() const {
+  return exerciseCode_;
+}
+
+void GlobalConfirmRequest::setExerciseCode(const std::string &exerciseCode) {
+  exerciseCode_ = exerciseCode;
+  setBodyParameter(std::string("ExerciseCode"), exerciseCode);
+}
+

aimath/src/model/GlobalConfirmResult.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/aimath/model/GlobalConfirmResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::AIMath;
+using namespace AlibabaCloud::AIMath::Model;
+
+GlobalConfirmResult::GlobalConfirmResult() :
+	ServiceResult()
+{}
+
+GlobalConfirmResult::GlobalConfirmResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GlobalConfirmResult::~GlobalConfirmResult()
+{}
+
+void GlobalConfirmResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrCode"].isNull())
+		errCode_ = value["ErrCode"].asString();
+	if(!value["ErrMsg"].isNull())
+		errMsg_ = value["ErrMsg"].asString();
+
+}
+
+std::string GlobalConfirmResult::getErrMsg()const
+{
+	return errMsg_;
+}
+
+bool GlobalConfirmResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string GlobalConfirmResult::getErrCode()const
+{
+	return errCode_;
+}
+

aimath/src/model/UpdateAnalysisRequest.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/aimath/model/UpdateAnalysisRequest.h>
+
+using AlibabaCloud::AIMath::Model::UpdateAnalysisRequest;
+
+UpdateAnalysisRequest::UpdateAnalysisRequest()
+    : RpcServiceRequest("aimath", "2024-11-14", "UpdateAnalysis") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateAnalysisRequest::~UpdateAnalysisRequest() {}
+
+std::string UpdateAnalysisRequest::getContent() const {
+  return content_;
+}
+
+void UpdateAnalysisRequest::setContent(const std::string &content) {
+  content_ = content;
+  setBodyParameter(std::string("Content"), content);
+}
+
+std::string UpdateAnalysisRequest::getContentCode() const {
+  return contentCode_;
+}
+
+void UpdateAnalysisRequest::setContentCode(const std::string &contentCode) {
+  contentCode_ = contentCode;
+  setBodyParameter(std::string("ContentCode"), contentCode);
+}
+
+std::string UpdateAnalysisRequest::getExerciseCode() const {
+  return exerciseCode_;
+}
+
+void UpdateAnalysisRequest::setExerciseCode(const std::string &exerciseCode) {
+  exerciseCode_ = exerciseCode;
+  setBodyParameter(std::string("ExerciseCode"), exerciseCode);
+}
+

aimath/src/model/UpdateAnalysisResult.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/aimath/model/UpdateAnalysisResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::AIMath;
+using namespace AlibabaCloud::AIMath::Model;
+
+UpdateAnalysisResult::UpdateAnalysisResult() :
+	ServiceResult()
+{}
+
+UpdateAnalysisResult::UpdateAnalysisResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateAnalysisResult::~UpdateAnalysisResult()
+{}
+
+void UpdateAnalysisResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrCode"].isNull())
+		errCode_ = value["ErrCode"].asString();
+	if(!value["ErrMsg"].isNull())
+		errMsg_ = value["ErrMsg"].asString();
+
+}
+
+std::string UpdateAnalysisResult::getErrMsg()const
+{
+	return errMsg_;
+}
+
+bool UpdateAnalysisResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string UpdateAnalysisResult::getErrCode()const
+{
+	return errCode_;
+}
+

aimath/src/model/UpdateStepRequest.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/aimath/model/UpdateStepRequest.h>
+
+using AlibabaCloud::AIMath::Model::UpdateStepRequest;
+
+UpdateStepRequest::UpdateStepRequest()
+    : RpcServiceRequest("aimath", "2024-11-14", "UpdateStep") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateStepRequest::~UpdateStepRequest() {}
+
+std::string UpdateStepRequest::getContent() const {
+  return content_;
+}
+
+void UpdateStepRequest::setContent(const std::string &content) {
+  content_ = content;
+  setBodyParameter(std::string("Content"), content);
+}
+
+std::string UpdateStepRequest::getContentCode() const {
+  return contentCode_;
+}
+
+void UpdateStepRequest::setContentCode(const std::string &contentCode) {
+  contentCode_ = contentCode;
+  setBodyParameter(std::string("ContentCode"), contentCode);
+}
+
+std::string UpdateStepRequest::getExerciseCode() const {
+  return exerciseCode_;
+}
+
+void UpdateStepRequest::setExerciseCode(const std::string &exerciseCode) {
+  exerciseCode_ = exerciseCode;
+  setBodyParameter(std::string("ExerciseCode"), exerciseCode);
+}
+

aimath/src/model/UpdateStepResult.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/aimath/model/UpdateStepResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::AIMath;
+using namespace AlibabaCloud::AIMath::Model;
+
+UpdateStepResult::UpdateStepResult() :
+	ServiceResult()
+{}
+
+UpdateStepResult::UpdateStepResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateStepResult::~UpdateStepResult()
+{}
+
+void UpdateStepResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrCode"].isNull())
+		errCode_ = value["ErrCode"].asString();
+	if(!value["ErrMsg"].isNull())
+		errMsg_ = value["ErrMsg"].asString();
+
+}
+
+std::string UpdateStepResult::getErrMsg()const
+{
+	return errMsg_;
+}
+
+bool UpdateStepResult::getSuccess()const
+{
+	return success_;
+}
+
+std::string UpdateStepResult::getErrCode()const
+{
+	return errCode_;
+}
+

alb/include/alibabacloud/alb/model/CreateListenerRequest.h

@@ -55,6 +55,8 @@ public:
 		std::string xForwardedForClientCertSubjectDNAlias;
 		bool xForwardedForClientSourceIpsEnabled;
 		bool xForwardedForClientCertIssuerDNEnabled;
+		bool xForwardedForHostEnabled;
+		std::string xForwardedForProcessingMode;
 		bool xForwardedForClientCertFingerprintEnabled;
 		std::string xForwardedForClientCertIssuerDNAlias;
 		bool xForwardedForProtoEnabled;

alb/include/alibabacloud/alb/model/CreateServerGroupRequest.h

@@ -70,6 +70,8 @@ public:
 	};
 	CreateServerGroupRequest();
 	~CreateServerGroupRequest();
+	bool getCrossZoneEnabled() const;
+	void setCrossZoneEnabled(bool crossZoneEnabled);
 	std::string getServerGroupName() const;
 	void setServerGroupName(const std::string &serverGroupName);
 	std::string getClientToken() const;
@@ -106,6 +108,7 @@ public:
 	void setUchConfig(const UchConfig &uchConfig);
 
 private:
+	bool crossZoneEnabled_;
 	std::string serverGroupName_;
 	std::string clientToken_;
 	HealthCheckConfig healthCheckConfig_;

alb/include/alibabacloud/alb/model/GetListenerAttributeResult.h

@@ -63,6 +63,7 @@ namespace AlibabaCloud
 					bool xForwardedForClientSourceIpsEnabled;
 					std::string xForwardedForClientCertFingerprintAlias;
 					bool xForwardedForClientCertFingerprintEnabled;
+					bool xForwardedForHostEnabled;
 					std::string xForwardedForClientSourceIpsTrusted;
 					std::string xForwardedForClientCertIssuerDNAlias;
 					std::string xForwardedForClientCertClientVerifyAlias;
@@ -72,6 +73,7 @@ namespace AlibabaCloud
 					bool xForwardedForProtoEnabled;
 					bool xForwardedForClientSrcPortEnabled;
 					bool xForwardedForEnabled;
+					std::string xForwardedForProcessingMode;
 					bool xForwardedForSLBPortEnabled;
 					bool xForwardedForClientCertIssuerDNEnabled;
 					bool xForwardedForClientCertClientVerifyEnabled;

alb/include/alibabacloud/alb/model/ListListenersResult.h

@@ -55,6 +55,7 @@ namespace AlibabaCloud
 						bool xForwardedForClientSourceIpsEnabled;
 						std::string xForwardedForClientCertFingerprintAlias;
 						bool xForwardedForClientCertFingerprintEnabled;
+						bool xForwardedForHostEnabled;
 						std::string xForwardedForClientSourceIpsTrusted;
 						std::string xForwardedForClientCertIssuerDNAlias;
 						std::string xForwardedForClientCertClientVerifyAlias;
@@ -64,6 +65,7 @@ namespace AlibabaCloud
 						bool xForwardedForProtoEnabled;
 						bool xForwardedForClientSrcPortEnabled;
 						bool xForwardedForEnabled;
+						std::string xForwardedForProcessingMode;
 						bool xForwardedForSLBPortEnabled;
 						bool xForwardedForClientCertIssuerDNEnabled;
 						bool xForwardedForClientCertClientVerifyEnabled;

alb/include/alibabacloud/alb/model/ListServerGroupsResult.h

@@ -84,6 +84,7 @@ namespace AlibabaCloud
 					std::string scheduler;
 					std::vector<std::string> relatedRuleIds;
 					int serverCount;
+					bool crossZoneEnabled;
 					bool ipv6Enabled;
 					SlowStartConfig slowStartConfig;
 					std::string serviceManagedMode;

alb/include/alibabacloud/alb/model/UpdateListenerAttributeRequest.h

@@ -51,6 +51,8 @@ public:
 		std::string xForwardedForClientCertSubjectDNAlias;
 		bool xForwardedForClientSourceIpsEnabled;
 		bool xForwardedForClientCertIssuerDNEnabled;
+		bool xForwardedForHostEnabled;
+		std::string xForwardedForProcessingMode;
 		bool xForwardedForClientCertFingerprintEnabled;
 		std::string xForwardedForClientCertIssuerDNAlias;
 		bool xForwardedForProtoEnabled;

alb/include/alibabacloud/alb/model/UpdateServerGroupAttributeRequest.h

@@ -66,6 +66,8 @@ public:
 	};
 	UpdateServerGroupAttributeRequest();
 	~UpdateServerGroupAttributeRequest();
+	bool getCrossZoneEnabled() const;
+	void setCrossZoneEnabled(bool crossZoneEnabled);
 	std::string getServerGroupName() const;
 	void setServerGroupName(const std::string &serverGroupName);
 	std::string getClientToken() const;
@@ -92,6 +94,7 @@ public:
 	void setUchConfig(const UchConfig &uchConfig);
 
 private:
+	bool crossZoneEnabled_;
 	std::string serverGroupName_;
 	std::string clientToken_;
 	HealthCheckConfig healthCheckConfig_;

alb/src/model/CreateListenerRequest.cc

@@ -136,6 +136,8 @@ void CreateListenerRequest::setXForwardedForConfig(const CreateListenerRequest::
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertSubjectDNAlias", xForwardedForConfig.xForwardedForClientCertSubjectDNAlias);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientSourceIpsEnabled", xForwardedForConfig.xForwardedForClientSourceIpsEnabled ? "true" : "false");
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertIssuerDNEnabled", xForwardedForConfig.xForwardedForClientCertIssuerDNEnabled ? "true" : "false");
+  setParameter(std::string("XForwardedForConfig") + ".XForwardedForHostEnabled", xForwardedForConfig.xForwardedForHostEnabled ? "true" : "false");
+  setParameter(std::string("XForwardedForConfig") + ".XForwardedForProcessingMode", xForwardedForConfig.xForwardedForProcessingMode);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertFingerprintEnabled", xForwardedForConfig.xForwardedForClientCertFingerprintEnabled ? "true" : "false");
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertIssuerDNAlias", xForwardedForConfig.xForwardedForClientCertIssuerDNAlias);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForProtoEnabled", xForwardedForConfig.xForwardedForProtoEnabled ? "true" : "false");

alb/src/model/CreateRulesRequest.cc

@@ -43,92 +43,92 @@ void CreateRulesRequest::setRules(const std::vector<CreateRulesRequest::Rules> &
   for(int dep1 = 0; dep1 != rules.size(); dep1++) {
     for(int dep2 = 0; dep2 != rules[dep1].ruleConditions.size(); dep2++) {
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].methodConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".MethodConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].methodConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".MethodConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].methodConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].sourceIpConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".SourceIpConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].sourceIpConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".SourceIpConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].sourceIpConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].hostConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HostConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].hostConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HostConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].hostConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].queryStringConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].value);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].key);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].value);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].key);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseStatusCodeConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseStatusCodeConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].pathConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".PathConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].pathConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".PathConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].pathConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].cookieConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].value);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].key);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].value);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].key);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleConditions[dep2].type);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleConditions[dep2].type);
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].headerConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].headerConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].headerConfig.values[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Key", rules[dep1].ruleConditions[dep2].headerConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Key", rules[dep1].ruleConditions[dep2].headerConfig.key);
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].responseHeaderConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseHeaderConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseHeaderConfig.values[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Key", rules[dep1].ruleConditions[dep2].responseHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Key", rules[dep1].ruleConditions[dep2].responseHeaderConfig.key);
     }
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleName", rules[dep1].ruleName);
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleName", rules[dep1].ruleName);
     for(int dep2 = 0; dep2 != rules[dep1].tag.size(); dep2++) {
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Tag." + std::to_string(dep2 + 1) + ".Value", rules[dep1].tag[dep2].value);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Tag." + std::to_string(dep2 + 1) + ".Key", rules[dep1].tag[dep2].key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Tag." + std::to_string(dep2 + 1) + ".Value", rules[dep1].tag[dep2].value);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Tag." + std::to_string(dep2 + 1) + ".Key", rules[dep1].tag[dep2].key);
     }
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Priority", std::to_string(rules[dep1].priority));
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Priority", std::to_string(rules[dep1].priority));
     for(int dep2 = 0; dep2 != rules[dep1].ruleActions.size(); dep2++) {
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.HttpCode", rules[dep1].ruleActions[dep2].fixedResponseConfig.httpCode);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.Content", rules[dep1].ruleActions[dep2].fixedResponseConfig.content);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.ContentType", rules[dep1].ruleActions[dep2].fixedResponseConfig.contentType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.HttpCode", rules[dep1].ruleActions[dep2].fixedResponseConfig.httpCode);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.Content", rules[dep1].ruleActions[dep2].fixedResponseConfig.content);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.ContentType", rules[dep1].ruleActions[dep2].fixedResponseConfig.contentType);
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.MirrorGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples[dep3].serverGroupId);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.MirrorGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples[dep3].serverGroupId);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.TargetType", rules[dep1].ruleActions[dep2].trafficMirrorConfig.targetType);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Enabled", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.enabled ? "true" : "false");
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Timeout", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.timeout));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.TargetType", rules[dep1].ruleActions[dep2].trafficMirrorConfig.targetType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Enabled", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.enabled ? "true" : "false");
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Timeout", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.timeout));
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].serverGroupId);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".Weight", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].weight));
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].serverGroupId);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".Weight", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].weight));
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RemoveHeaderConfig.Key", rules[dep1].ruleActions[dep2].removeHeaderConfig.key);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.ValueType", rules[dep1].ruleActions[dep2].insertHeaderConfig.valueType);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.CoverEnabled", rules[dep1].ruleActions[dep2].insertHeaderConfig.coverEnabled ? "true" : "false");
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Value", rules[dep1].ruleActions[dep2].insertHeaderConfig.value);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Key", rules[dep1].ruleActions[dep2].insertHeaderConfig.key);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.QPS", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.qPS));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.PerIpQps", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.perIpQps));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowCredentials", rules[dep1].ruleActions[dep2].corsConfig.allowCredentials);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RemoveHeaderConfig.Key", rules[dep1].ruleActions[dep2].removeHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.ValueType", rules[dep1].ruleActions[dep2].insertHeaderConfig.valueType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.CoverEnabled", rules[dep1].ruleActions[dep2].insertHeaderConfig.coverEnabled ? "true" : "false");
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Value", rules[dep1].ruleActions[dep2].insertHeaderConfig.value);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Key", rules[dep1].ruleActions[dep2].insertHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.QPS", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.qPS));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.PerIpQps", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.perIpQps));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowCredentials", rules[dep1].ruleActions[dep2].corsConfig.allowCredentials);
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowOrigin.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowOrigin." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowOrigin[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowOrigin." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowOrigin[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.MaxAge", std::to_string(rules[dep1].ruleActions[dep2].corsConfig.maxAge));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.MaxAge", std::to_string(rules[dep1].ruleActions[dep2].corsConfig.maxAge));
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowMethods.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowMethods." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowMethods[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowMethods." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowMethods[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowHeaders.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowHeaders[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowHeaders[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.ExposeHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.ExposeHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Path", rules[dep1].ruleActions[dep2].redirectConfig.path);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Protocol", rules[dep1].ruleActions[dep2].redirectConfig.protocol);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Port", rules[dep1].ruleActions[dep2].redirectConfig.port);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Query", rules[dep1].ruleActions[dep2].redirectConfig.query);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Host", rules[dep1].ruleActions[dep2].redirectConfig.host);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.HttpCode", rules[dep1].ruleActions[dep2].redirectConfig.httpCode);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleActions[dep2].type);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Order", std::to_string(rules[dep1].ruleActions[dep2].order));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Path", rules[dep1].ruleActions[dep2].rewriteConfig.path);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Query", rules[dep1].ruleActions[dep2].rewriteConfig.query);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Host", rules[dep1].ruleActions[dep2].rewriteConfig.host);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Path", rules[dep1].ruleActions[dep2].redirectConfig.path);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Protocol", rules[dep1].ruleActions[dep2].redirectConfig.protocol);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Port", rules[dep1].ruleActions[dep2].redirectConfig.port);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Query", rules[dep1].ruleActions[dep2].redirectConfig.query);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Host", rules[dep1].ruleActions[dep2].redirectConfig.host);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.HttpCode", rules[dep1].ruleActions[dep2].redirectConfig.httpCode);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleActions[dep2].type);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Order", std::to_string(rules[dep1].ruleActions[dep2].order));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Path", rules[dep1].ruleActions[dep2].rewriteConfig.path);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Query", rules[dep1].ruleActions[dep2].rewriteConfig.query);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Host", rules[dep1].ruleActions[dep2].rewriteConfig.host);
     }
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Direction", rules[dep1].direction);
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Direction", rules[dep1].direction);
   }
 }
 

alb/src/model/CreateServerGroupRequest.cc

@@ -25,6 +25,15 @@ CreateServerGroupRequest::CreateServerGroupRequest()
 
 CreateServerGroupRequest::~CreateServerGroupRequest() {}
 
+bool CreateServerGroupRequest::getCrossZoneEnabled() const {
+  return crossZoneEnabled_;
+}
+
+void CreateServerGroupRequest::setCrossZoneEnabled(bool crossZoneEnabled) {
+  crossZoneEnabled_ = crossZoneEnabled;
+  setParameter(std::string("CrossZoneEnabled"), crossZoneEnabled ? "true" : "false");
+}
+
 std::string CreateServerGroupRequest::getServerGroupName() const {
   return serverGroupName_;
 }

alb/src/model/GetListenerAttributeResult.cc

@@ -151,6 +151,8 @@ void GetListenerAttributeResult::parse(const std::string &payload)
 		xForwardedForConfig_.xForwardedForClientSrcPortEnabled = xForwardedForConfigNode["XForwardedForClientSrcPortEnabled"].asString() == "true";
 	if(!xForwardedForConfigNode["XForwardedForEnabled"].isNull())
 		xForwardedForConfig_.xForwardedForEnabled = xForwardedForConfigNode["XForwardedForEnabled"].asString() == "true";
+	if(!xForwardedForConfigNode["XForwardedForProcessingMode"].isNull())
+		xForwardedForConfig_.xForwardedForProcessingMode = xForwardedForConfigNode["XForwardedForProcessingMode"].asString();
 	if(!xForwardedForConfigNode["XForwardedForProtoEnabled"].isNull())
 		xForwardedForConfig_.xForwardedForProtoEnabled = xForwardedForConfigNode["XForwardedForProtoEnabled"].asString() == "true";
 	if(!xForwardedForConfigNode["XForwardedForSLBIdEnabled"].isNull())
@@ -161,6 +163,8 @@ void GetListenerAttributeResult::parse(const std::string &payload)
 		xForwardedForConfig_.xForwardedForClientSourceIpsEnabled = xForwardedForConfigNode["XForwardedForClientSourceIpsEnabled"].asString() == "true";
 	if(!xForwardedForConfigNode["XForwardedForClientSourceIpsTrusted"].isNull())
 		xForwardedForConfig_.xForwardedForClientSourceIpsTrusted = xForwardedForConfigNode["XForwardedForClientSourceIpsTrusted"].asString();
+	if(!xForwardedForConfigNode["XForwardedForHostEnabled"].isNull())
+		xForwardedForConfig_.xForwardedForHostEnabled = xForwardedForConfigNode["XForwardedForHostEnabled"].asString() == "true";
 	if(!value["CaEnabled"].isNull())
 		caEnabled_ = value["CaEnabled"].asString() == "true";
 	if(!value["GzipEnabled"].isNull())

alb/src/model/ListListenersResult.cc

@@ -148,6 +148,8 @@ void ListListenersResult::parse(const std::string &payload)
 			listenersObject.xForwardedForConfig.xForwardedForClientSrcPortEnabled = xForwardedForConfigNode["XForwardedForClientSrcPortEnabled"].asString() == "true";
 		if(!xForwardedForConfigNode["XForwardedForEnabled"].isNull())
 			listenersObject.xForwardedForConfig.xForwardedForEnabled = xForwardedForConfigNode["XForwardedForEnabled"].asString() == "true";
+		if(!xForwardedForConfigNode["XForwardedForProcessingMode"].isNull())
+			listenersObject.xForwardedForConfig.xForwardedForProcessingMode = xForwardedForConfigNode["XForwardedForProcessingMode"].asString();
 		if(!xForwardedForConfigNode["XForwardedForProtoEnabled"].isNull())
 			listenersObject.xForwardedForConfig.xForwardedForProtoEnabled = xForwardedForConfigNode["XForwardedForProtoEnabled"].asString() == "true";
 		if(!xForwardedForConfigNode["XForwardedForSLBIdEnabled"].isNull())
@@ -158,6 +160,8 @@ void ListListenersResult::parse(const std::string &payload)
 			listenersObject.xForwardedForConfig.xForwardedForClientSourceIpsEnabled = xForwardedForConfigNode["XForwardedForClientSourceIpsEnabled"].asString() == "true";
 		if(!xForwardedForConfigNode["XForwardedForClientSourceIpsTrusted"].isNull())
 			listenersObject.xForwardedForConfig.xForwardedForClientSourceIpsTrusted = xForwardedForConfigNode["XForwardedForClientSourceIpsTrusted"].asString();
+		if(!xForwardedForConfigNode["XForwardedForHostEnabled"].isNull())
+			listenersObject.xForwardedForConfig.xForwardedForHostEnabled = xForwardedForConfigNode["XForwardedForHostEnabled"].asString() == "true";
 		listeners_.push_back(listenersObject);
 	}
 	if(!value["MaxResults"].isNull())

alb/src/model/ListServerGroupsResult.cc

@@ -75,6 +75,8 @@ void ListServerGroupsResult::parse(const std::string &payload)
 			serverGroupsObject.serviceName = valueServerGroupsServerGroup["ServiceName"].asString();
 		if(!valueServerGroupsServerGroup["CreateTime"].isNull())
 			serverGroupsObject.createTime = valueServerGroupsServerGroup["CreateTime"].asString();
+		if(!valueServerGroupsServerGroup["CrossZoneEnabled"].isNull())
+			serverGroupsObject.crossZoneEnabled = valueServerGroupsServerGroup["CrossZoneEnabled"].asString() == "true";
 		auto allTagsNode = valueServerGroupsServerGroup["Tags"]["Tag"];
 		for (auto valueServerGroupsServerGroupTagsTag : allTagsNode)
 		{

alb/src/model/UpdateListenerAttributeRequest.cc

@@ -124,6 +124,8 @@ void UpdateListenerAttributeRequest::setXForwardedForConfig(const UpdateListener
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertSubjectDNAlias", xForwardedForConfig.xForwardedForClientCertSubjectDNAlias);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientSourceIpsEnabled", xForwardedForConfig.xForwardedForClientSourceIpsEnabled ? "true" : "false");
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertIssuerDNEnabled", xForwardedForConfig.xForwardedForClientCertIssuerDNEnabled ? "true" : "false");
+  setParameter(std::string("XForwardedForConfig") + ".XForwardedForHostEnabled", xForwardedForConfig.xForwardedForHostEnabled ? "true" : "false");
+  setParameter(std::string("XForwardedForConfig") + ".XForwardedForProcessingMode", xForwardedForConfig.xForwardedForProcessingMode);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertFingerprintEnabled", xForwardedForConfig.xForwardedForClientCertFingerprintEnabled ? "true" : "false");
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForClientCertIssuerDNAlias", xForwardedForConfig.xForwardedForClientCertIssuerDNAlias);
   setParameter(std::string("XForwardedForConfig") + ".XForwardedForProtoEnabled", xForwardedForConfig.xForwardedForProtoEnabled ? "true" : "false");

alb/src/model/UpdateRulesAttributeRequest.cc

@@ -43,87 +43,87 @@ void UpdateRulesAttributeRequest::setRules(const std::vector<UpdateRulesAttribut
   for(int dep1 = 0; dep1 != rules.size(); dep1++) {
     for(int dep2 = 0; dep2 != rules[dep1].ruleConditions.size(); dep2++) {
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].methodConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".MethodConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].methodConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".MethodConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].methodConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].sourceIpConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".SourceIpConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].sourceIpConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".SourceIpConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].sourceIpConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].hostConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HostConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].hostConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HostConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].hostConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].queryStringConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].value);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].key);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].value);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".QueryStringConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].queryStringConfig.values[dep3].key);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseStatusCodeConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseStatusCodeConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseStatusCodeConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].pathConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".PathConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].pathConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".PathConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].pathConfig.values[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].cookieConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].value);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].key);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Value", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].value);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".CookieConfig.Values." + std::to_string(dep3 + 1) + ".Key", rules[dep1].ruleConditions[dep2].cookieConfig.values[dep3].key);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleConditions[dep2].type);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleConditions[dep2].type);
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].headerConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].headerConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].headerConfig.values[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Key", rules[dep1].ruleConditions[dep2].headerConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".HeaderConfig.Key", rules[dep1].ruleConditions[dep2].headerConfig.key);
       for(int dep3 = 0; dep3 != rules[dep1].ruleConditions[dep2].responseHeaderConfig.values.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseHeaderConfig.values[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Values." + std::to_string(dep3 + 1), rules[dep1].ruleConditions[dep2].responseHeaderConfig.values[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Key", rules[dep1].ruleConditions[dep2].responseHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleConditions." + std::to_string(dep2 + 1) + ".ResponseHeaderConfig.Key", rules[dep1].ruleConditions[dep2].responseHeaderConfig.key);
     }
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleName", rules[dep1].ruleName);
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Priority", std::to_string(rules[dep1].priority));
-    setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleId", rules[dep1].ruleId);
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleName", rules[dep1].ruleName);
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".Priority", std::to_string(rules[dep1].priority));
+    setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleId", rules[dep1].ruleId);
     for(int dep2 = 0; dep2 != rules[dep1].ruleActions.size(); dep2++) {
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.HttpCode", rules[dep1].ruleActions[dep2].fixedResponseConfig.httpCode);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.Content", rules[dep1].ruleActions[dep2].fixedResponseConfig.content);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.ContentType", rules[dep1].ruleActions[dep2].fixedResponseConfig.contentType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.HttpCode", rules[dep1].ruleActions[dep2].fixedResponseConfig.httpCode);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.Content", rules[dep1].ruleActions[dep2].fixedResponseConfig.content);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".FixedResponseConfig.ContentType", rules[dep1].ruleActions[dep2].fixedResponseConfig.contentType);
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.MirrorGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples[dep3].serverGroupId);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.MirrorGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].trafficMirrorConfig.mirrorGroupConfig.serverGroupTuples[dep3].serverGroupId);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.TargetType", rules[dep1].ruleActions[dep2].trafficMirrorConfig.targetType);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Enabled", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.enabled ? "true" : "false");
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Timeout", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.timeout));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficMirrorConfig.TargetType", rules[dep1].ruleActions[dep2].trafficMirrorConfig.targetType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Enabled", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.enabled ? "true" : "false");
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupStickySession.Timeout", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupStickySession.timeout));
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].serverGroupId);
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".Weight", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].weight));
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".ServerGroupId", rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].serverGroupId);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".ForwardGroupConfig.ServerGroupTuples." + std::to_string(dep3 + 1) + ".Weight", std::to_string(rules[dep1].ruleActions[dep2].forwardGroupConfig.serverGroupTuples[dep3].weight));
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RemoveHeaderConfig.Key", rules[dep1].ruleActions[dep2].removeHeaderConfig.key);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.ValueType", rules[dep1].ruleActions[dep2].insertHeaderConfig.valueType);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.CoverEnabled", rules[dep1].ruleActions[dep2].insertHeaderConfig.coverEnabled ? "true" : "false");
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Value", rules[dep1].ruleActions[dep2].insertHeaderConfig.value);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Key", rules[dep1].ruleActions[dep2].insertHeaderConfig.key);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.QPS", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.qPS));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.PerIpQps", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.perIpQps));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowCredentials", rules[dep1].ruleActions[dep2].corsConfig.allowCredentials);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RemoveHeaderConfig.Key", rules[dep1].ruleActions[dep2].removeHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.ValueType", rules[dep1].ruleActions[dep2].insertHeaderConfig.valueType);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.CoverEnabled", rules[dep1].ruleActions[dep2].insertHeaderConfig.coverEnabled ? "true" : "false");
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Value", rules[dep1].ruleActions[dep2].insertHeaderConfig.value);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".InsertHeaderConfig.Key", rules[dep1].ruleActions[dep2].insertHeaderConfig.key);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.QPS", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.qPS));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".TrafficLimitConfig.PerIpQps", std::to_string(rules[dep1].ruleActions[dep2].trafficLimitConfig.perIpQps));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowCredentials", rules[dep1].ruleActions[dep2].corsConfig.allowCredentials);
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowOrigin.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowOrigin." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowOrigin[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowOrigin." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowOrigin[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.MaxAge", std::to_string(rules[dep1].ruleActions[dep2].corsConfig.maxAge));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.MaxAge", std::to_string(rules[dep1].ruleActions[dep2].corsConfig.maxAge));
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowMethods.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowMethods." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowMethods[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowMethods." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowMethods[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.allowHeaders.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowHeaders[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.AllowHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.allowHeaders[dep3]);
       }
       for(int dep3 = 0; dep3 != rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders.size(); dep3++) {
-        setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.ExposeHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders[dep3]);
+        setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".CorsConfig.ExposeHeaders." + std::to_string(dep3 + 1), rules[dep1].ruleActions[dep2].corsConfig.exposeHeaders[dep3]);
       }
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Path", rules[dep1].ruleActions[dep2].redirectConfig.path);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Protocol", rules[dep1].ruleActions[dep2].redirectConfig.protocol);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Port", rules[dep1].ruleActions[dep2].redirectConfig.port);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Query", rules[dep1].ruleActions[dep2].redirectConfig.query);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Host", rules[dep1].ruleActions[dep2].redirectConfig.host);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.HttpCode", rules[dep1].ruleActions[dep2].redirectConfig.httpCode);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleActions[dep2].type);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Order", std::to_string(rules[dep1].ruleActions[dep2].order));
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Path", rules[dep1].ruleActions[dep2].rewriteConfig.path);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Query", rules[dep1].ruleActions[dep2].rewriteConfig.query);
-      setParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Host", rules[dep1].ruleActions[dep2].rewriteConfig.host);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Path", rules[dep1].ruleActions[dep2].redirectConfig.path);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Protocol", rules[dep1].ruleActions[dep2].redirectConfig.protocol);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Port", rules[dep1].ruleActions[dep2].redirectConfig.port);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Query", rules[dep1].ruleActions[dep2].redirectConfig.query);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.Host", rules[dep1].ruleActions[dep2].redirectConfig.host);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RedirectConfig.HttpCode", rules[dep1].ruleActions[dep2].redirectConfig.httpCode);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Type", rules[dep1].ruleActions[dep2].type);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".Order", std::to_string(rules[dep1].ruleActions[dep2].order));
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Path", rules[dep1].ruleActions[dep2].rewriteConfig.path);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Query", rules[dep1].ruleActions[dep2].rewriteConfig.query);
+      setBodyParameter(std::string("Rules") + "." + std::to_string(dep1 + 1) + ".RuleActions." + std::to_string(dep2 + 1) + ".RewriteConfig.Host", rules[dep1].ruleActions[dep2].rewriteConfig.host);
     }
   }
 }

alb/src/model/UpdateServerGroupAttributeRequest.cc

@@ -25,6 +25,15 @@ UpdateServerGroupAttributeRequest::UpdateServerGroupAttributeRequest()
 
 UpdateServerGroupAttributeRequest::~UpdateServerGroupAttributeRequest() {}
 
+bool UpdateServerGroupAttributeRequest::getCrossZoneEnabled() const {
+  return crossZoneEnabled_;
+}
+
+void UpdateServerGroupAttributeRequest::setCrossZoneEnabled(bool crossZoneEnabled) {
+  crossZoneEnabled_ = crossZoneEnabled;
+  setParameter(std::string("CrossZoneEnabled"), crossZoneEnabled ? "true" : "false");
+}
+
 std::string UpdateServerGroupAttributeRequest::getServerGroupName() const {
   return serverGroupName_;
 }

csas/CMakeLists.txt

@@ -23,6 +23,10 @@ set(csas_public_header
 set(csas_public_header_model 
 	include/alibabacloud/csas/model/AttachApplication2ConnectorRequest.h
 	include/alibabacloud/csas/model/AttachApplication2ConnectorResult.h
+	include/alibabacloud/csas/model/AttachPolicy2ApprovalProcessRequest.h
+	include/alibabacloud/csas/model/AttachPolicy2ApprovalProcessResult.h
+	include/alibabacloud/csas/model/CreateApprovalProcessRequest.h
+	include/alibabacloud/csas/model/CreateApprovalProcessResult.h
 	include/alibabacloud/csas/model/CreateClientUserRequest.h
 	include/alibabacloud/csas/model/CreateClientUserResult.h
 	include/alibabacloud/csas/model/CreateDynamicRouteRequest.h
@@ -47,6 +51,8 @@ set(csas_public_header_model
 	include/alibabacloud/csas/model/CreateWmExtractTaskResult.h
 	include/alibabacloud/csas/model/CreateWmInfoMappingRequest.h
 	include/alibabacloud/csas/model/CreateWmInfoMappingResult.h
+	include/alibabacloud/csas/model/DeleteApprovalProcessesRequest.h
+	include/alibabacloud/csas/model/DeleteApprovalProcessesResult.h
 	include/alibabacloud/csas/model/DeleteClientUserRequest.h
 	include/alibabacloud/csas/model/DeleteClientUserResult.h
 	include/alibabacloud/csas/model/DeleteDynamicRouteRequest.h
@@ -67,10 +73,20 @@ set(csas_public_header_model
 	include/alibabacloud/csas/model/DeleteUserGroupResult.h
 	include/alibabacloud/csas/model/DetachApplication2ConnectorRequest.h
 	include/alibabacloud/csas/model/DetachApplication2ConnectorResult.h
+	include/alibabacloud/csas/model/DetachPolicy2ApprovalProcessRequest.h
+	include/alibabacloud/csas/model/DetachPolicy2ApprovalProcessResult.h
 	include/alibabacloud/csas/model/ExportUserDevicesRequest.h
 	include/alibabacloud/csas/model/ExportUserDevicesResult.h
 	include/alibabacloud/csas/model/GetActiveIdpConfigRequest.h
 	include/alibabacloud/csas/model/GetActiveIdpConfigResult.h
+	include/alibabacloud/csas/model/GetApprovalRequest.h
+	include/alibabacloud/csas/model/GetApprovalResult.h
+	include/alibabacloud/csas/model/GetApprovalProcessRequest.h
+	include/alibabacloud/csas/model/GetApprovalProcessResult.h
+	include/alibabacloud/csas/model/GetApprovalSchemaRequest.h
+	include/alibabacloud/csas/model/GetApprovalSchemaResult.h
+	include/alibabacloud/csas/model/GetBootAndAntiUninstallPolicyRequest.h
+	include/alibabacloud/csas/model/GetBootAndAntiUninstallPolicyResult.h
 	include/alibabacloud/csas/model/GetClientUserRequest.h
 	include/alibabacloud/csas/model/GetClientUserResult.h
 	include/alibabacloud/csas/model/GetDynamicRouteRequest.h
@@ -95,6 +111,16 @@ set(csas_public_header_model
 	include/alibabacloud/csas/model/ListApplicationsForPrivateAccessPolicyResult.h
 	include/alibabacloud/csas/model/ListApplicationsForPrivateAccessTagRequest.h
 	include/alibabacloud/csas/model/ListApplicationsForPrivateAccessTagResult.h
+	include/alibabacloud/csas/model/ListApprovalProcessesRequest.h
+	include/alibabacloud/csas/model/ListApprovalProcessesResult.h
+	include/alibabacloud/csas/model/ListApprovalProcessesForApprovalSchemasRequest.h
+	include/alibabacloud/csas/model/ListApprovalProcessesForApprovalSchemasResult.h
+	include/alibabacloud/csas/model/ListApprovalSchemasRequest.h
+	include/alibabacloud/csas/model/ListApprovalSchemasResult.h
+	include/alibabacloud/csas/model/ListApprovalSchemasForApprovalProcessesRequest.h
+	include/alibabacloud/csas/model/ListApprovalSchemasForApprovalProcessesResult.h
+	include/alibabacloud/csas/model/ListApprovalsRequest.h
+	include/alibabacloud/csas/model/ListApprovalsResult.h
 	include/alibabacloud/csas/model/ListClientUsersRequest.h
 	include/alibabacloud/csas/model/ListClientUsersResult.h
 	include/alibabacloud/csas/model/ListConnectorsRequest.h
@@ -139,6 +165,10 @@ set(csas_public_header_model
 	include/alibabacloud/csas/model/ListTagsForPrivateAccessApplicationResult.h
 	include/alibabacloud/csas/model/ListTagsForPrivateAccessPolicyRequest.h
 	include/alibabacloud/csas/model/ListTagsForPrivateAccessPolicyResult.h
+	include/alibabacloud/csas/model/ListUninstallApplicationsRequest.h
+	include/alibabacloud/csas/model/ListUninstallApplicationsResult.h
+	include/alibabacloud/csas/model/ListUserApplicationsRequest.h
+	include/alibabacloud/csas/model/ListUserApplicationsResult.h
 	include/alibabacloud/csas/model/ListUserDevicesRequest.h
 	include/alibabacloud/csas/model/ListUserDevicesResult.h
 	include/alibabacloud/csas/model/ListUserGroupsRequest.h
@@ -147,12 +177,20 @@ set(csas_public_header_model
 	include/alibabacloud/csas/model/ListUserGroupsForPrivateAccessPolicyResult.h
 	include/alibabacloud/csas/model/ListUserGroupsForRegistrationPolicyRequest.h
 	include/alibabacloud/csas/model/ListUserGroupsForRegistrationPolicyResult.h
+	include/alibabacloud/csas/model/ListUserPrivateAccessPoliciesRequest.h
+	include/alibabacloud/csas/model/ListUserPrivateAccessPoliciesResult.h
 	include/alibabacloud/csas/model/ListUsersRequest.h
 	include/alibabacloud/csas/model/ListUsersResult.h
 	include/alibabacloud/csas/model/LookupWmInfoMappingRequest.h
 	include/alibabacloud/csas/model/LookupWmInfoMappingResult.h
 	include/alibabacloud/csas/model/RevokeUserSessionRequest.h
 	include/alibabacloud/csas/model/RevokeUserSessionResult.h
+	include/alibabacloud/csas/model/UpdateApprovalProcessRequest.h
+	include/alibabacloud/csas/model/UpdateApprovalProcessResult.h
+	include/alibabacloud/csas/model/UpdateApprovalStatusRequest.h
+	include/alibabacloud/csas/model/UpdateApprovalStatusResult.h
+	include/alibabacloud/csas/model/UpdateBootAndAntiUninstallPolicyRequest.h
+	include/alibabacloud/csas/model/UpdateBootAndAntiUninstallPolicyResult.h
 	include/alibabacloud/csas/model/UpdateClientUserRequest.h
 	include/alibabacloud/csas/model/UpdateClientUserResult.h
 	include/alibabacloud/csas/model/UpdateClientUserPasswordRequest.h
@@ -173,6 +211,8 @@ set(csas_public_header_model
 	include/alibabacloud/csas/model/UpdatePrivateAccessPolicyResult.h
 	include/alibabacloud/csas/model/UpdateRegistrationPolicyRequest.h
 	include/alibabacloud/csas/model/UpdateRegistrationPolicyResult.h
+	include/alibabacloud/csas/model/UpdateUninstallApplicationsStatusRequest.h
+	include/alibabacloud/csas/model/UpdateUninstallApplicationsStatusResult.h
 	include/alibabacloud/csas/model/UpdateUserDevicesSharingStatusRequest.h
 	include/alibabacloud/csas/model/UpdateUserDevicesSharingStatusResult.h
 	include/alibabacloud/csas/model/UpdateUserDevicesStatusRequest.h
@@ -186,6 +226,10 @@ set(csas_src
 	src/CsasClient.cc
 	src/model/AttachApplication2ConnectorRequest.cc
 	src/model/AttachApplication2ConnectorResult.cc
+	src/model/AttachPolicy2ApprovalProcessRequest.cc
+	src/model/AttachPolicy2ApprovalProcessResult.cc
+	src/model/CreateApprovalProcessRequest.cc
+	src/model/CreateApprovalProcessResult.cc
 	src/model/CreateClientUserRequest.cc
 	src/model/CreateClientUserResult.cc
 	src/model/CreateDynamicRouteRequest.cc
@@ -210,6 +254,8 @@ set(csas_src
 	src/model/CreateWmExtractTaskResult.cc
 	src/model/CreateWmInfoMappingRequest.cc
 	src/model/CreateWmInfoMappingResult.cc
+	src/model/DeleteApprovalProcessesRequest.cc
+	src/model/DeleteApprovalProcessesResult.cc
 	src/model/DeleteClientUserRequest.cc
 	src/model/DeleteClientUserResult.cc
 	src/model/DeleteDynamicRouteRequest.cc
@@ -230,10 +276,20 @@ set(csas_src
 	src/model/DeleteUserGroupResult.cc
 	src/model/DetachApplication2ConnectorRequest.cc
 	src/model/DetachApplication2ConnectorResult.cc
+	src/model/DetachPolicy2ApprovalProcessRequest.cc
+	src/model/DetachPolicy2ApprovalProcessResult.cc
 	src/model/ExportUserDevicesRequest.cc
 	src/model/ExportUserDevicesResult.cc
 	src/model/GetActiveIdpConfigRequest.cc
 	src/model/GetActiveIdpConfigResult.cc
+	src/model/GetApprovalRequest.cc
+	src/model/GetApprovalResult.cc
+	src/model/GetApprovalProcessRequest.cc
+	src/model/GetApprovalProcessResult.cc
+	src/model/GetApprovalSchemaRequest.cc
+	src/model/GetApprovalSchemaResult.cc
+	src/model/GetBootAndAntiUninstallPolicyRequest.cc
+	src/model/GetBootAndAntiUninstallPolicyResult.cc
 	src/model/GetClientUserRequest.cc
 	src/model/GetClientUserResult.cc
 	src/model/GetDynamicRouteRequest.cc
@@ -258,6 +314,16 @@ set(csas_src
 	src/model/ListApplicationsForPrivateAccessPolicyResult.cc
 	src/model/ListApplicationsForPrivateAccessTagRequest.cc
 	src/model/ListApplicationsForPrivateAccessTagResult.cc
+	src/model/ListApprovalProcessesRequest.cc
+	src/model/ListApprovalProcessesResult.cc
+	src/model/ListApprovalProcessesForApprovalSchemasRequest.cc
+	src/model/ListApprovalProcessesForApprovalSchemasResult.cc
+	src/model/ListApprovalSchemasRequest.cc
+	src/model/ListApprovalSchemasResult.cc
+	src/model/ListApprovalSchemasForApprovalProcessesRequest.cc
+	src/model/ListApprovalSchemasForApprovalProcessesResult.cc
+	src/model/ListApprovalsRequest.cc
+	src/model/ListApprovalsResult.cc
 	src/model/ListClientUsersRequest.cc
 	src/model/ListClientUsersResult.cc
 	src/model/ListConnectorsRequest.cc
@@ -302,6 +368,10 @@ set(csas_src
 	src/model/ListTagsForPrivateAccessApplicationResult.cc
 	src/model/ListTagsForPrivateAccessPolicyRequest.cc
 	src/model/ListTagsForPrivateAccessPolicyResult.cc
+	src/model/ListUninstallApplicationsRequest.cc
+	src/model/ListUninstallApplicationsResult.cc
+	src/model/ListUserApplicationsRequest.cc
+	src/model/ListUserApplicationsResult.cc
 	src/model/ListUserDevicesRequest.cc
 	src/model/ListUserDevicesResult.cc
 	src/model/ListUserGroupsRequest.cc
@@ -310,12 +380,20 @@ set(csas_src
 	src/model/ListUserGroupsForPrivateAccessPolicyResult.cc
 	src/model/ListUserGroupsForRegistrationPolicyRequest.cc
 	src/model/ListUserGroupsForRegistrationPolicyResult.cc
+	src/model/ListUserPrivateAccessPoliciesRequest.cc
+	src/model/ListUserPrivateAccessPoliciesResult.cc
 	src/model/ListUsersRequest.cc
 	src/model/ListUsersResult.cc
 	src/model/LookupWmInfoMappingRequest.cc
 	src/model/LookupWmInfoMappingResult.cc
 	src/model/RevokeUserSessionRequest.cc
 	src/model/RevokeUserSessionResult.cc
+	src/model/UpdateApprovalProcessRequest.cc
+	src/model/UpdateApprovalProcessResult.cc
+	src/model/UpdateApprovalStatusRequest.cc
+	src/model/UpdateApprovalStatusResult.cc
+	src/model/UpdateBootAndAntiUninstallPolicyRequest.cc
+	src/model/UpdateBootAndAntiUninstallPolicyResult.cc
 	src/model/UpdateClientUserRequest.cc
 	src/model/UpdateClientUserResult.cc
 	src/model/UpdateClientUserPasswordRequest.cc
@@ -336,6 +414,8 @@ set(csas_src
 	src/model/UpdatePrivateAccessPolicyResult.cc
 	src/model/UpdateRegistrationPolicyRequest.cc
 	src/model/UpdateRegistrationPolicyResult.cc
+	src/model/UpdateUninstallApplicationsStatusRequest.cc
+	src/model/UpdateUninstallApplicationsStatusResult.cc
 	src/model/UpdateUserDevicesSharingStatusRequest.cc
 	src/model/UpdateUserDevicesSharingStatusResult.cc
 	src/model/UpdateUserDevicesStatusRequest.cc

csas/include/alibabacloud/csas/CsasClient.h

@@ -24,6 +24,10 @@
 #include "CsasExport.h"
 #include "model/AttachApplication2ConnectorRequest.h"
 #include "model/AttachApplication2ConnectorResult.h"
+#include "model/AttachPolicy2ApprovalProcessRequest.h"
+#include "model/AttachPolicy2ApprovalProcessResult.h"
+#include "model/CreateApprovalProcessRequest.h"
+#include "model/CreateApprovalProcessResult.h"
 #include "model/CreateClientUserRequest.h"
 #include "model/CreateClientUserResult.h"
 #include "model/CreateDynamicRouteRequest.h"
@@ -48,6 +52,8 @@
 #include "model/CreateWmExtractTaskResult.h"
 #include "model/CreateWmInfoMappingRequest.h"
 #include "model/CreateWmInfoMappingResult.h"
+#include "model/DeleteApprovalProcessesRequest.h"
+#include "model/DeleteApprovalProcessesResult.h"
 #include "model/DeleteClientUserRequest.h"
 #include "model/DeleteClientUserResult.h"
 #include "model/DeleteDynamicRouteRequest.h"
@@ -68,10 +74,20 @@
 #include "model/DeleteUserGroupResult.h"
 #include "model/DetachApplication2ConnectorRequest.h"
 #include "model/DetachApplication2ConnectorResult.h"
+#include "model/DetachPolicy2ApprovalProcessRequest.h"
+#include "model/DetachPolicy2ApprovalProcessResult.h"
 #include "model/ExportUserDevicesRequest.h"
 #include "model/ExportUserDevicesResult.h"
 #include "model/GetActiveIdpConfigRequest.h"
 #include "model/GetActiveIdpConfigResult.h"
+#include "model/GetApprovalRequest.h"
+#include "model/GetApprovalResult.h"
+#include "model/GetApprovalProcessRequest.h"
+#include "model/GetApprovalProcessResult.h"
+#include "model/GetApprovalSchemaRequest.h"
+#include "model/GetApprovalSchemaResult.h"
+#include "model/GetBootAndAntiUninstallPolicyRequest.h"
+#include "model/GetBootAndAntiUninstallPolicyResult.h"
 #include "model/GetClientUserRequest.h"
 #include "model/GetClientUserResult.h"
 #include "model/GetDynamicRouteRequest.h"
@@ -96,6 +112,16 @@
 #include "model/ListApplicationsForPrivateAccessPolicyResult.h"
 #include "model/ListApplicationsForPrivateAccessTagRequest.h"
 #include "model/ListApplicationsForPrivateAccessTagResult.h"
+#include "model/ListApprovalProcessesRequest.h"
+#include "model/ListApprovalProcessesResult.h"
+#include "model/ListApprovalProcessesForApprovalSchemasRequest.h"
+#include "model/ListApprovalProcessesForApprovalSchemasResult.h"
+#include "model/ListApprovalSchemasRequest.h"
+#include "model/ListApprovalSchemasResult.h"
+#include "model/ListApprovalSchemasForApprovalProcessesRequest.h"
+#include "model/ListApprovalSchemasForApprovalProcessesResult.h"
+#include "model/ListApprovalsRequest.h"
+#include "model/ListApprovalsResult.h"
 #include "model/ListClientUsersRequest.h"
 #include "model/ListClientUsersResult.h"
 #include "model/ListConnectorsRequest.h"
@@ -140,6 +166,10 @@
 #include "model/ListTagsForPrivateAccessApplicationResult.h"
 #include "model/ListTagsForPrivateAccessPolicyRequest.h"
 #include "model/ListTagsForPrivateAccessPolicyResult.h"
+#include "model/ListUninstallApplicationsRequest.h"
+#include "model/ListUninstallApplicationsResult.h"
+#include "model/ListUserApplicationsRequest.h"
+#include "model/ListUserApplicationsResult.h"
 #include "model/ListUserDevicesRequest.h"
 #include "model/ListUserDevicesResult.h"
 #include "model/ListUserGroupsRequest.h"
@@ -148,12 +178,20 @@
 #include "model/ListUserGroupsForPrivateAccessPolicyResult.h"
 #include "model/ListUserGroupsForRegistrationPolicyRequest.h"
 #include "model/ListUserGroupsForRegistrationPolicyResult.h"
+#include "model/ListUserPrivateAccessPoliciesRequest.h"
+#include "model/ListUserPrivateAccessPoliciesResult.h"
 #include "model/ListUsersRequest.h"
 #include "model/ListUsersResult.h"
 #include "model/LookupWmInfoMappingRequest.h"
 #include "model/LookupWmInfoMappingResult.h"
 #include "model/RevokeUserSessionRequest.h"
 #include "model/RevokeUserSessionResult.h"
+#include "model/UpdateApprovalProcessRequest.h"
+#include "model/UpdateApprovalProcessResult.h"
+#include "model/UpdateApprovalStatusRequest.h"
+#include "model/UpdateApprovalStatusResult.h"
+#include "model/UpdateBootAndAntiUninstallPolicyRequest.h"
+#include "model/UpdateBootAndAntiUninstallPolicyResult.h"
 #include "model/UpdateClientUserRequest.h"
 #include "model/UpdateClientUserResult.h"
 #include "model/UpdateClientUserPasswordRequest.h"
@@ -174,6 +212,8 @@
 #include "model/UpdatePrivateAccessPolicyResult.h"
 #include "model/UpdateRegistrationPolicyRequest.h"
 #include "model/UpdateRegistrationPolicyResult.h"
+#include "model/UpdateUninstallApplicationsStatusRequest.h"
+#include "model/UpdateUninstallApplicationsStatusResult.h"
 #include "model/UpdateUserDevicesSharingStatusRequest.h"
 #include "model/UpdateUserDevicesSharingStatusResult.h"
 #include "model/UpdateUserDevicesStatusRequest.h"
@@ -194,6 +234,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AttachApplication2ConnectorResult> AttachApplication2ConnectorOutcome;
 			typedef std::future<AttachApplication2ConnectorOutcome> AttachApplication2ConnectorOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::AttachApplication2ConnectorRequest&, const AttachApplication2ConnectorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachApplication2ConnectorAsyncHandler;
+			typedef Outcome<Error, Model::AttachPolicy2ApprovalProcessResult> AttachPolicy2ApprovalProcessOutcome;
+			typedef std::future<AttachPolicy2ApprovalProcessOutcome> AttachPolicy2ApprovalProcessOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::AttachPolicy2ApprovalProcessRequest&, const AttachPolicy2ApprovalProcessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachPolicy2ApprovalProcessAsyncHandler;
+			typedef Outcome<Error, Model::CreateApprovalProcessResult> CreateApprovalProcessOutcome;
+			typedef std::future<CreateApprovalProcessOutcome> CreateApprovalProcessOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::CreateApprovalProcessRequest&, const CreateApprovalProcessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateApprovalProcessAsyncHandler;
 			typedef Outcome<Error, Model::CreateClientUserResult> CreateClientUserOutcome;
 			typedef std::future<CreateClientUserOutcome> CreateClientUserOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::CreateClientUserRequest&, const CreateClientUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateClientUserAsyncHandler;
@@ -230,6 +276,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateWmInfoMappingResult> CreateWmInfoMappingOutcome;
 			typedef std::future<CreateWmInfoMappingOutcome> CreateWmInfoMappingOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::CreateWmInfoMappingRequest&, const CreateWmInfoMappingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateWmInfoMappingAsyncHandler;
+			typedef Outcome<Error, Model::DeleteApprovalProcessesResult> DeleteApprovalProcessesOutcome;
+			typedef std::future<DeleteApprovalProcessesOutcome> DeleteApprovalProcessesOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::DeleteApprovalProcessesRequest&, const DeleteApprovalProcessesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteApprovalProcessesAsyncHandler;
 			typedef Outcome<Error, Model::DeleteClientUserResult> DeleteClientUserOutcome;
 			typedef std::future<DeleteClientUserOutcome> DeleteClientUserOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::DeleteClientUserRequest&, const DeleteClientUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteClientUserAsyncHandler;
@@ -260,12 +309,27 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DetachApplication2ConnectorResult> DetachApplication2ConnectorOutcome;
 			typedef std::future<DetachApplication2ConnectorOutcome> DetachApplication2ConnectorOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::DetachApplication2ConnectorRequest&, const DetachApplication2ConnectorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachApplication2ConnectorAsyncHandler;
+			typedef Outcome<Error, Model::DetachPolicy2ApprovalProcessResult> DetachPolicy2ApprovalProcessOutcome;
+			typedef std::future<DetachPolicy2ApprovalProcessOutcome> DetachPolicy2ApprovalProcessOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::DetachPolicy2ApprovalProcessRequest&, const DetachPolicy2ApprovalProcessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachPolicy2ApprovalProcessAsyncHandler;
 			typedef Outcome<Error, Model::ExportUserDevicesResult> ExportUserDevicesOutcome;
 			typedef std::future<ExportUserDevicesOutcome> ExportUserDevicesOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::ExportUserDevicesRequest&, const ExportUserDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportUserDevicesAsyncHandler;
 			typedef Outcome<Error, Model::GetActiveIdpConfigResult> GetActiveIdpConfigOutcome;
 			typedef std::future<GetActiveIdpConfigOutcome> GetActiveIdpConfigOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::GetActiveIdpConfigRequest&, const GetActiveIdpConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetActiveIdpConfigAsyncHandler;
+			typedef Outcome<Error, Model::GetApprovalResult> GetApprovalOutcome;
+			typedef std::future<GetApprovalOutcome> GetApprovalOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::GetApprovalRequest&, const GetApprovalOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetApprovalAsyncHandler;
+			typedef Outcome<Error, Model::GetApprovalProcessResult> GetApprovalProcessOutcome;
+			typedef std::future<GetApprovalProcessOutcome> GetApprovalProcessOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::GetApprovalProcessRequest&, const GetApprovalProcessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetApprovalProcessAsyncHandler;
+			typedef Outcome<Error, Model::GetApprovalSchemaResult> GetApprovalSchemaOutcome;
+			typedef std::future<GetApprovalSchemaOutcome> GetApprovalSchemaOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::GetApprovalSchemaRequest&, const GetApprovalSchemaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetApprovalSchemaAsyncHandler;
+			typedef Outcome<Error, Model::GetBootAndAntiUninstallPolicyResult> GetBootAndAntiUninstallPolicyOutcome;
+			typedef std::future<GetBootAndAntiUninstallPolicyOutcome> GetBootAndAntiUninstallPolicyOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::GetBootAndAntiUninstallPolicyRequest&, const GetBootAndAntiUninstallPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetBootAndAntiUninstallPolicyAsyncHandler;
 			typedef Outcome<Error, Model::GetClientUserResult> GetClientUserOutcome;
 			typedef std::future<GetClientUserOutcome> GetClientUserOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::GetClientUserRequest&, const GetClientUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetClientUserAsyncHandler;
@@ -302,6 +366,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListApplicationsForPrivateAccessTagResult> ListApplicationsForPrivateAccessTagOutcome;
 			typedef std::future<ListApplicationsForPrivateAccessTagOutcome> ListApplicationsForPrivateAccessTagOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::ListApplicationsForPrivateAccessTagRequest&, const ListApplicationsForPrivateAccessTagOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListApplicationsForPrivateAccessTagAsyncHandler;
+			typedef Outcome<Error, Model::ListApprovalProcessesResult> ListApprovalProcessesOutcome;
+			typedef std::future<ListApprovalProcessesOutcome> ListApprovalProcessesOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::ListApprovalProcessesRequest&, const ListApprovalProcessesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListApprovalProcessesAsyncHandler;
+			typedef Outcome<Error, Model::ListApprovalProcessesForApprovalSchemasResult> ListApprovalProcessesForApprovalSchemasOutcome;
+			typedef std::future<ListApprovalProcessesForApprovalSchemasOutcome> ListApprovalProcessesForApprovalSchemasOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::ListApprovalProcessesForApprovalSchemasRequest&, const ListApprovalProcessesForApprovalSchemasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListApprovalProcessesForApprovalSchemasAsyncHandler;
+			typedef Outcome<Error, Model::ListApprovalSchemasResult> ListApprovalSchemasOutcome;
+			typedef std::future<ListApprovalSchemasOutcome> ListApprovalSchemasOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::ListApprovalSchemasRequest&, const ListApprovalSchemasOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListApprovalSchemasAsyncHandler;
+			typedef Outcome<Error, Model::ListApprovalSchemasForApprovalProcessesResult> ListApprovalSchemasForApprovalProcessesOutcome;
+			typedef std::future<ListApprovalSchemasForApprovalProcessesOutcome> ListApprovalSchemasForApprovalProcessesOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::ListApprovalSchemasForApprovalProcessesRequest&, const ListApprovalSchemasForApprovalProcessesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListApprovalSchemasForApprovalProcessesAsyncHandler;
+			typedef Outcome<Error, Model::ListApprovalsResult> ListApprovalsOutcome;
+			typedef std::future<ListApprovalsOutcome> ListApprovalsOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::ListApprovalsRequest&, const ListApprovalsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListApprovalsAsyncHandler;
 			typedef Outcome<Error, Model::ListClientUsersResult> ListClientUsersOutcome;
 			typedef std::future<ListClientUsersOutcome> ListClientUsersOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::ListClientUsersRequest&, const ListClientUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClientUsersAsyncHandler;
@@ -368,6 +447,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListTagsForPrivateAccessPolicyResult> ListTagsForPrivateAccessPolicyOutcome;
 			typedef std::future<ListTagsForPrivateAccessPolicyOutcome> ListTagsForPrivateAccessPolicyOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::ListTagsForPrivateAccessPolicyRequest&, const ListTagsForPrivateAccessPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagsForPrivateAccessPolicyAsyncHandler;
+			typedef Outcome<Error, Model::ListUninstallApplicationsResult> ListUninstallApplicationsOutcome;
+			typedef std::future<ListUninstallApplicationsOutcome> ListUninstallApplicationsOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::ListUninstallApplicationsRequest&, const ListUninstallApplicationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUninstallApplicationsAsyncHandler;
+			typedef Outcome<Error, Model::ListUserApplicationsResult> ListUserApplicationsOutcome;
+			typedef std::future<ListUserApplicationsOutcome> ListUserApplicationsOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::ListUserApplicationsRequest&, const ListUserApplicationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUserApplicationsAsyncHandler;
 			typedef Outcome<Error, Model::ListUserDevicesResult> ListUserDevicesOutcome;
 			typedef std::future<ListUserDevicesOutcome> ListUserDevicesOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::ListUserDevicesRequest&, const ListUserDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUserDevicesAsyncHandler;
@@ -380,6 +465,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListUserGroupsForRegistrationPolicyResult> ListUserGroupsForRegistrationPolicyOutcome;
 			typedef std::future<ListUserGroupsForRegistrationPolicyOutcome> ListUserGroupsForRegistrationPolicyOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::ListUserGroupsForRegistrationPolicyRequest&, const ListUserGroupsForRegistrationPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUserGroupsForRegistrationPolicyAsyncHandler;
+			typedef Outcome<Error, Model::ListUserPrivateAccessPoliciesResult> ListUserPrivateAccessPoliciesOutcome;
+			typedef std::future<ListUserPrivateAccessPoliciesOutcome> ListUserPrivateAccessPoliciesOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::ListUserPrivateAccessPoliciesRequest&, const ListUserPrivateAccessPoliciesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUserPrivateAccessPoliciesAsyncHandler;
 			typedef Outcome<Error, Model::ListUsersResult> ListUsersOutcome;
 			typedef std::future<ListUsersOutcome> ListUsersOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::ListUsersRequest&, const ListUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUsersAsyncHandler;
@@ -389,6 +477,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RevokeUserSessionResult> RevokeUserSessionOutcome;
 			typedef std::future<RevokeUserSessionOutcome> RevokeUserSessionOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::RevokeUserSessionRequest&, const RevokeUserSessionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RevokeUserSessionAsyncHandler;
+			typedef Outcome<Error, Model::UpdateApprovalProcessResult> UpdateApprovalProcessOutcome;
+			typedef std::future<UpdateApprovalProcessOutcome> UpdateApprovalProcessOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::UpdateApprovalProcessRequest&, const UpdateApprovalProcessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateApprovalProcessAsyncHandler;
+			typedef Outcome<Error, Model::UpdateApprovalStatusResult> UpdateApprovalStatusOutcome;
+			typedef std::future<UpdateApprovalStatusOutcome> UpdateApprovalStatusOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::UpdateApprovalStatusRequest&, const UpdateApprovalStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateApprovalStatusAsyncHandler;
+			typedef Outcome<Error, Model::UpdateBootAndAntiUninstallPolicyResult> UpdateBootAndAntiUninstallPolicyOutcome;
+			typedef std::future<UpdateBootAndAntiUninstallPolicyOutcome> UpdateBootAndAntiUninstallPolicyOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::UpdateBootAndAntiUninstallPolicyRequest&, const UpdateBootAndAntiUninstallPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateBootAndAntiUninstallPolicyAsyncHandler;
 			typedef Outcome<Error, Model::UpdateClientUserResult> UpdateClientUserOutcome;
 			typedef std::future<UpdateClientUserOutcome> UpdateClientUserOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::UpdateClientUserRequest&, const UpdateClientUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateClientUserAsyncHandler;
@@ -419,6 +516,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateRegistrationPolicyResult> UpdateRegistrationPolicyOutcome;
 			typedef std::future<UpdateRegistrationPolicyOutcome> UpdateRegistrationPolicyOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::UpdateRegistrationPolicyRequest&, const UpdateRegistrationPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateRegistrationPolicyAsyncHandler;
+			typedef Outcome<Error, Model::UpdateUninstallApplicationsStatusResult> UpdateUninstallApplicationsStatusOutcome;
+			typedef std::future<UpdateUninstallApplicationsStatusOutcome> UpdateUninstallApplicationsStatusOutcomeCallable;
+			typedef std::function<void(const CsasClient*, const Model::UpdateUninstallApplicationsStatusRequest&, const UpdateUninstallApplicationsStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateUninstallApplicationsStatusAsyncHandler;
 			typedef Outcome<Error, Model::UpdateUserDevicesSharingStatusResult> UpdateUserDevicesSharingStatusOutcome;
 			typedef std::future<UpdateUserDevicesSharingStatusOutcome> UpdateUserDevicesSharingStatusOutcomeCallable;
 			typedef std::function<void(const CsasClient*, const Model::UpdateUserDevicesSharingStatusRequest&, const UpdateUserDevicesSharingStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateUserDevicesSharingStatusAsyncHandler;
@@ -439,6 +539,12 @@ namespace AlibabaCloud
 			AttachApplication2ConnectorOutcome attachApplication2Connector(const Model::AttachApplication2ConnectorRequest &request)const;
 			void attachApplication2ConnectorAsync(const Model::AttachApplication2ConnectorRequest& request, const AttachApplication2ConnectorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AttachApplication2ConnectorOutcomeCallable attachApplication2ConnectorCallable(const Model::AttachApplication2ConnectorRequest& request) const;
+			AttachPolicy2ApprovalProcessOutcome attachPolicy2ApprovalProcess(const Model::AttachPolicy2ApprovalProcessRequest &request)const;
+			void attachPolicy2ApprovalProcessAsync(const Model::AttachPolicy2ApprovalProcessRequest& request, const AttachPolicy2ApprovalProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachPolicy2ApprovalProcessOutcomeCallable attachPolicy2ApprovalProcessCallable(const Model::AttachPolicy2ApprovalProcessRequest& request) const;
+			CreateApprovalProcessOutcome createApprovalProcess(const Model::CreateApprovalProcessRequest &request)const;
+			void createApprovalProcessAsync(const Model::CreateApprovalProcessRequest& request, const CreateApprovalProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateApprovalProcessOutcomeCallable createApprovalProcessCallable(const Model::CreateApprovalProcessRequest& request) const;
 			CreateClientUserOutcome createClientUser(const Model::CreateClientUserRequest &request)const;
 			void createClientUserAsync(const Model::CreateClientUserRequest& request, const CreateClientUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateClientUserOutcomeCallable createClientUserCallable(const Model::CreateClientUserRequest& request) const;
@@ -475,6 +581,9 @@ namespace AlibabaCloud
 			CreateWmInfoMappingOutcome createWmInfoMapping(const Model::CreateWmInfoMappingRequest &request)const;
 			void createWmInfoMappingAsync(const Model::CreateWmInfoMappingRequest& request, const CreateWmInfoMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateWmInfoMappingOutcomeCallable createWmInfoMappingCallable(const Model::CreateWmInfoMappingRequest& request) const;
+			DeleteApprovalProcessesOutcome deleteApprovalProcesses(const Model::DeleteApprovalProcessesRequest &request)const;
+			void deleteApprovalProcessesAsync(const Model::DeleteApprovalProcessesRequest& request, const DeleteApprovalProcessesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteApprovalProcessesOutcomeCallable deleteApprovalProcessesCallable(const Model::DeleteApprovalProcessesRequest& request) const;
 			DeleteClientUserOutcome deleteClientUser(const Model::DeleteClientUserRequest &request)const;
 			void deleteClientUserAsync(const Model::DeleteClientUserRequest& request, const DeleteClientUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteClientUserOutcomeCallable deleteClientUserCallable(const Model::DeleteClientUserRequest& request) const;
@@ -505,12 +614,27 @@ namespace AlibabaCloud
 			DetachApplication2ConnectorOutcome detachApplication2Connector(const Model::DetachApplication2ConnectorRequest &request)const;
 			void detachApplication2ConnectorAsync(const Model::DetachApplication2ConnectorRequest& request, const DetachApplication2ConnectorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetachApplication2ConnectorOutcomeCallable detachApplication2ConnectorCallable(const Model::DetachApplication2ConnectorRequest& request) const;
+			DetachPolicy2ApprovalProcessOutcome detachPolicy2ApprovalProcess(const Model::DetachPolicy2ApprovalProcessRequest &request)const;
+			void detachPolicy2ApprovalProcessAsync(const Model::DetachPolicy2ApprovalProcessRequest& request, const DetachPolicy2ApprovalProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachPolicy2ApprovalProcessOutcomeCallable detachPolicy2ApprovalProcessCallable(const Model::DetachPolicy2ApprovalProcessRequest& request) const;
 			ExportUserDevicesOutcome exportUserDevices(const Model::ExportUserDevicesRequest &request)const;
 			void exportUserDevicesAsync(const Model::ExportUserDevicesRequest& request, const ExportUserDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExportUserDevicesOutcomeCallable exportUserDevicesCallable(const Model::ExportUserDevicesRequest& request) const;
 			GetActiveIdpConfigOutcome getActiveIdpConfig(const Model::GetActiveIdpConfigRequest &request)const;
 			void getActiveIdpConfigAsync(const Model::GetActiveIdpConfigRequest& request, const GetActiveIdpConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetActiveIdpConfigOutcomeCallable getActiveIdpConfigCallable(const Model::GetActiveIdpConfigRequest& request) const;
+			GetApprovalOutcome getApproval(const Model::GetApprovalRequest &request)const;
+			void getApprovalAsync(const Model::GetApprovalRequest& request, const GetApprovalAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetApprovalOutcomeCallable getApprovalCallable(const Model::GetApprovalRequest& request) const;
+			GetApprovalProcessOutcome getApprovalProcess(const Model::GetApprovalProcessRequest &request)const;
+			void getApprovalProcessAsync(const Model::GetApprovalProcessRequest& request, const GetApprovalProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetApprovalProcessOutcomeCallable getApprovalProcessCallable(const Model::GetApprovalProcessRequest& request) const;
+			GetApprovalSchemaOutcome getApprovalSchema(const Model::GetApprovalSchemaRequest &request)const;
+			void getApprovalSchemaAsync(const Model::GetApprovalSchemaRequest& request, const GetApprovalSchemaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetApprovalSchemaOutcomeCallable getApprovalSchemaCallable(const Model::GetApprovalSchemaRequest& request) const;
+			GetBootAndAntiUninstallPolicyOutcome getBootAndAntiUninstallPolicy(const Model::GetBootAndAntiUninstallPolicyRequest &request)const;
+			void getBootAndAntiUninstallPolicyAsync(const Model::GetBootAndAntiUninstallPolicyRequest& request, const GetBootAndAntiUninstallPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetBootAndAntiUninstallPolicyOutcomeCallable getBootAndAntiUninstallPolicyCallable(const Model::GetBootAndAntiUninstallPolicyRequest& request) const;
 			GetClientUserOutcome getClientUser(const Model::GetClientUserRequest &request)const;
 			void getClientUserAsync(const Model::GetClientUserRequest& request, const GetClientUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetClientUserOutcomeCallable getClientUserCallable(const Model::GetClientUserRequest& request) const;
@@ -547,6 +671,21 @@ namespace AlibabaCloud
 			ListApplicationsForPrivateAccessTagOutcome listApplicationsForPrivateAccessTag(const Model::ListApplicationsForPrivateAccessTagRequest &request)const;
 			void listApplicationsForPrivateAccessTagAsync(const Model::ListApplicationsForPrivateAccessTagRequest& request, const ListApplicationsForPrivateAccessTagAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListApplicationsForPrivateAccessTagOutcomeCallable listApplicationsForPrivateAccessTagCallable(const Model::ListApplicationsForPrivateAccessTagRequest& request) const;
+			ListApprovalProcessesOutcome listApprovalProcesses(const Model::ListApprovalProcessesRequest &request)const;
+			void listApprovalProcessesAsync(const Model::ListApprovalProcessesRequest& request, const ListApprovalProcessesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListApprovalProcessesOutcomeCallable listApprovalProcessesCallable(const Model::ListApprovalProcessesRequest& request) const;
+			ListApprovalProcessesForApprovalSchemasOutcome listApprovalProcessesForApprovalSchemas(const Model::ListApprovalProcessesForApprovalSchemasRequest &request)const;
+			void listApprovalProcessesForApprovalSchemasAsync(const Model::ListApprovalProcessesForApprovalSchemasRequest& request, const ListApprovalProcessesForApprovalSchemasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListApprovalProcessesForApprovalSchemasOutcomeCallable listApprovalProcessesForApprovalSchemasCallable(const Model::ListApprovalProcessesForApprovalSchemasRequest& request) const;
+			ListApprovalSchemasOutcome listApprovalSchemas(const Model::ListApprovalSchemasRequest &request)const;
+			void listApprovalSchemasAsync(const Model::ListApprovalSchemasRequest& request, const ListApprovalSchemasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListApprovalSchemasOutcomeCallable listApprovalSchemasCallable(const Model::ListApprovalSchemasRequest& request) const;
+			ListApprovalSchemasForApprovalProcessesOutcome listApprovalSchemasForApprovalProcesses(const Model::ListApprovalSchemasForApprovalProcessesRequest &request)const;
+			void listApprovalSchemasForApprovalProcessesAsync(const Model::ListApprovalSchemasForApprovalProcessesRequest& request, const ListApprovalSchemasForApprovalProcessesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListApprovalSchemasForApprovalProcessesOutcomeCallable listApprovalSchemasForApprovalProcessesCallable(const Model::ListApprovalSchemasForApprovalProcessesRequest& request) const;
+			ListApprovalsOutcome listApprovals(const Model::ListApprovalsRequest &request)const;
+			void listApprovalsAsync(const Model::ListApprovalsRequest& request, const ListApprovalsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListApprovalsOutcomeCallable listApprovalsCallable(const Model::ListApprovalsRequest& request) const;
 			ListClientUsersOutcome listClientUsers(const Model::ListClientUsersRequest &request)const;
 			void listClientUsersAsync(const Model::ListClientUsersRequest& request, const ListClientUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListClientUsersOutcomeCallable listClientUsersCallable(const Model::ListClientUsersRequest& request) const;
@@ -613,6 +752,12 @@ namespace AlibabaCloud
 			ListTagsForPrivateAccessPolicyOutcome listTagsForPrivateAccessPolicy(const Model::ListTagsForPrivateAccessPolicyRequest &request)const;
 			void listTagsForPrivateAccessPolicyAsync(const Model::ListTagsForPrivateAccessPolicyRequest& request, const ListTagsForPrivateAccessPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListTagsForPrivateAccessPolicyOutcomeCallable listTagsForPrivateAccessPolicyCallable(const Model::ListTagsForPrivateAccessPolicyRequest& request) const;
+			ListUninstallApplicationsOutcome listUninstallApplications(const Model::ListUninstallApplicationsRequest &request)const;
+			void listUninstallApplicationsAsync(const Model::ListUninstallApplicationsRequest& request, const ListUninstallApplicationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListUninstallApplicationsOutcomeCallable listUninstallApplicationsCallable(const Model::ListUninstallApplicationsRequest& request) const;
+			ListUserApplicationsOutcome listUserApplications(const Model::ListUserApplicationsRequest &request)const;
+			void listUserApplicationsAsync(const Model::ListUserApplicationsRequest& request, const ListUserApplicationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListUserApplicationsOutcomeCallable listUserApplicationsCallable(const Model::ListUserApplicationsRequest& request) const;
 			ListUserDevicesOutcome listUserDevices(const Model::ListUserDevicesRequest &request)const;
 			void listUserDevicesAsync(const Model::ListUserDevicesRequest& request, const ListUserDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListUserDevicesOutcomeCallable listUserDevicesCallable(const Model::ListUserDevicesRequest& request) const;
@@ -625,6 +770,9 @@ namespace AlibabaCloud
 			ListUserGroupsForRegistrationPolicyOutcome listUserGroupsForRegistrationPolicy(const Model::ListUserGroupsForRegistrationPolicyRequest &request)const;
 			void listUserGroupsForRegistrationPolicyAsync(const Model::ListUserGroupsForRegistrationPolicyRequest& request, const ListUserGroupsForRegistrationPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListUserGroupsForRegistrationPolicyOutcomeCallable listUserGroupsForRegistrationPolicyCallable(const Model::ListUserGroupsForRegistrationPolicyRequest& request) const;
+			ListUserPrivateAccessPoliciesOutcome listUserPrivateAccessPolicies(const Model::ListUserPrivateAccessPoliciesRequest &request)const;
+			void listUserPrivateAccessPoliciesAsync(const Model::ListUserPrivateAccessPoliciesRequest& request, const ListUserPrivateAccessPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListUserPrivateAccessPoliciesOutcomeCallable listUserPrivateAccessPoliciesCallable(const Model::ListUserPrivateAccessPoliciesRequest& request) const;
 			ListUsersOutcome listUsers(const Model::ListUsersRequest &request)const;
 			void listUsersAsync(const Model::ListUsersRequest& request, const ListUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListUsersOutcomeCallable listUsersCallable(const Model::ListUsersRequest& request) const;
@@ -634,6 +782,15 @@ namespace AlibabaCloud
 			RevokeUserSessionOutcome revokeUserSession(const Model::RevokeUserSessionRequest &request)const;
 			void revokeUserSessionAsync(const Model::RevokeUserSessionRequest& request, const RevokeUserSessionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RevokeUserSessionOutcomeCallable revokeUserSessionCallable(const Model::RevokeUserSessionRequest& request) const;
+			UpdateApprovalProcessOutcome updateApprovalProcess(const Model::UpdateApprovalProcessRequest &request)const;
+			void updateApprovalProcessAsync(const Model::UpdateApprovalProcessRequest& request, const UpdateApprovalProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateApprovalProcessOutcomeCallable updateApprovalProcessCallable(const Model::UpdateApprovalProcessRequest& request) const;
+			UpdateApprovalStatusOutcome updateApprovalStatus(const Model::UpdateApprovalStatusRequest &request)const;
+			void updateApprovalStatusAsync(const Model::UpdateApprovalStatusRequest& request, const UpdateApprovalStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateApprovalStatusOutcomeCallable updateApprovalStatusCallable(const Model::UpdateApprovalStatusRequest& request) const;
+			UpdateBootAndAntiUninstallPolicyOutcome updateBootAndAntiUninstallPolicy(const Model::UpdateBootAndAntiUninstallPolicyRequest &request)const;
+			void updateBootAndAntiUninstallPolicyAsync(const Model::UpdateBootAndAntiUninstallPolicyRequest& request, const UpdateBootAndAntiUninstallPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateBootAndAntiUninstallPolicyOutcomeCallable updateBootAndAntiUninstallPolicyCallable(const Model::UpdateBootAndAntiUninstallPolicyRequest& request) const;
 			UpdateClientUserOutcome updateClientUser(const Model::UpdateClientUserRequest &request)const;
 			void updateClientUserAsync(const Model::UpdateClientUserRequest& request, const UpdateClientUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateClientUserOutcomeCallable updateClientUserCallable(const Model::UpdateClientUserRequest& request) const;
@@ -664,6 +821,9 @@ namespace AlibabaCloud
 			UpdateRegistrationPolicyOutcome updateRegistrationPolicy(const Model::UpdateRegistrationPolicyRequest &request)const;
 			void updateRegistrationPolicyAsync(const Model::UpdateRegistrationPolicyRequest& request, const UpdateRegistrationPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateRegistrationPolicyOutcomeCallable updateRegistrationPolicyCallable(const Model::UpdateRegistrationPolicyRequest& request) const;
+			UpdateUninstallApplicationsStatusOutcome updateUninstallApplicationsStatus(const Model::UpdateUninstallApplicationsStatusRequest &request)const;
+			void updateUninstallApplicationsStatusAsync(const Model::UpdateUninstallApplicationsStatusRequest& request, const UpdateUninstallApplicationsStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateUninstallApplicationsStatusOutcomeCallable updateUninstallApplicationsStatusCallable(const Model::UpdateUninstallApplicationsStatusRequest& request) const;
 			UpdateUserDevicesSharingStatusOutcome updateUserDevicesSharingStatus(const Model::UpdateUserDevicesSharingStatusRequest &request)const;
 			void updateUserDevicesSharingStatusAsync(const Model::UpdateUserDevicesSharingStatusRequest& request, const UpdateUserDevicesSharingStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateUserDevicesSharingStatusOutcomeCallable updateUserDevicesSharingStatusCallable(const Model::UpdateUserDevicesSharingStatusRequest& request) const;

csas/include/alibabacloud/csas/model/AttachPolicy2ApprovalProcessRequest.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_CSAS_MODEL_ATTACHPOLICY2APPROVALPROCESSREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_ATTACHPOLICY2APPROVALPROCESSREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT AttachPolicy2ApprovalProcessRequest : public RpcServiceRequest {
+public:
+	AttachPolicy2ApprovalProcessRequest();
+	~AttachPolicy2ApprovalProcessRequest();
+	std::string getPolicyType() const;
+	void setPolicyType(const std::string &policyType);
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getProcessId() const;
+	void setProcessId(const std::string &processId);
+
+private:
+	std::string policyType_;
+	std::string sourceIp_;
+	std::string policyId_;
+	std::string processId_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_ATTACHPOLICY2APPROVALPROCESSREQUEST_H_

csas/include/alibabacloud/csas/model/AttachPolicy2ApprovalProcessResult.h

@@ -14,38 +14,36 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_PAIFEATURESTORE_MODEL_LISTPROJECTFEATUREVIEWOWNERSRESULT_H_
-#define ALIBABACLOUD_PAIFEATURESTORE_MODEL_LISTPROJECTFEATUREVIEWOWNERSRESULT_H_
+#ifndef ALIBABACLOUD_CSAS_MODEL_ATTACHPOLICY2APPROVALPROCESSRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_ATTACHPOLICY2APPROVALPROCESSRESULT_H_
 
 #include <string>
 #include <vector>
 #include <utility>
 #include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/paifeaturestore/PaiFeatureStoreExport.h>
+#include <alibabacloud/csas/CsasExport.h>
 
 namespace AlibabaCloud
 {
-	namespace PaiFeatureStore
+	namespace Csas
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_PAIFEATURESTORE_EXPORT ListProjectFeatureViewOwnersResult : public ServiceResult
+			class ALIBABACLOUD_CSAS_EXPORT AttachPolicy2ApprovalProcessResult : public ServiceResult
 			{
 			public:
 
 
-				ListProjectFeatureViewOwnersResult();
-				explicit ListProjectFeatureViewOwnersResult(const std::string &payload);
-				~ListProjectFeatureViewOwnersResult();
-				std::vector<std::string> getOwners()const;
+				AttachPolicy2ApprovalProcessResult();
+				explicit AttachPolicy2ApprovalProcessResult(const std::string &payload);
+				~AttachPolicy2ApprovalProcessResult();
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<std::string> owners_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_PAIFEATURESTORE_MODEL_LISTPROJECTFEATUREVIEWOWNERSRESULT_H_
+#endif // !ALIBABACLOUD_CSAS_MODEL_ATTACHPOLICY2APPROVALPROCESSRESULT_H_

csas/include/alibabacloud/csas/model/CreateApprovalProcessRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CSAS_MODEL_CREATEAPPROVALPROCESSREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_CREATEAPPROVALPROCESSREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT CreateApprovalProcessRequest : public RpcServiceRequest {
+public:
+	struct MatchSchemas {
+		std::string domainBlacklistSchemaId;
+		std::string softwareBlockSchemaId;
+		std::string peripheralBlockSchemaId;
+		std::string deviceRegistrationSchemaId;
+		std::string dlpSendSchemaId;
+		std::string domainWhitelistSchemaId;
+		std::string appUninstallSchemaId;
+	};
+	CreateApprovalProcessRequest();
+	~CreateApprovalProcessRequest();
+	std::vector<std::vector<std::string>> getProcessNodes() const;
+	void setProcessNodes(const std::vector<std::vector<std::string>> &processNodes);
+	MatchSchemas getMatchSchemas() const;
+	void setMatchSchemas(const MatchSchemas &matchSchemas);
+	std::string getProcessName() const;
+	void setProcessName(const std::string &processName);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+
+private:
+	std::vector<std::vector<std::string>> processNodes_;
+	MatchSchemas matchSchemas_;
+	std::string processName_;
+	std::string description_;
+	std::string sourceIp_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_CREATEAPPROVALPROCESSREQUEST_H_

csas/include/alibabacloud/csas/model/CreateApprovalProcessResult.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_CSAS_MODEL_CREATEAPPROVALPROCESSRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_CREATEAPPROVALPROCESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT CreateApprovalProcessResult : public ServiceResult
+			{
+			public:
+
+
+				CreateApprovalProcessResult();
+				explicit CreateApprovalProcessResult(const std::string &payload);
+				~CreateApprovalProcessResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_CREATEAPPROVALPROCESSRESULT_H_

csas/include/alibabacloud/csas/model/DeleteApprovalProcessesRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_CSAS_MODEL_DELETEAPPROVALPROCESSESREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_DELETEAPPROVALPROCESSESREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT DeleteApprovalProcessesRequest : public RpcServiceRequest {
+public:
+	DeleteApprovalProcessesRequest();
+	~DeleteApprovalProcessesRequest();
+	std::vector<std::string> getProcessIds() const;
+	void setProcessIds(const std::vector<std::string> &processIds);
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+
+private:
+	std::vector<std::string> processIds_;
+	std::string sourceIp_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_DELETEAPPROVALPROCESSESREQUEST_H_

csas/include/alibabacloud/csas/model/DeleteApprovalProcessesResult.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_CSAS_MODEL_DELETEAPPROVALPROCESSESRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_DELETEAPPROVALPROCESSESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT DeleteApprovalProcessesResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteApprovalProcessesResult();
+				explicit DeleteApprovalProcessesResult(const std::string &payload);
+				~DeleteApprovalProcessesResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_DELETEAPPROVALPROCESSESRESULT_H_

csas/include/alibabacloud/csas/model/DetachPolicy2ApprovalProcessRequest.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_CSAS_MODEL_DETACHPOLICY2APPROVALPROCESSREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_DETACHPOLICY2APPROVALPROCESSREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT DetachPolicy2ApprovalProcessRequest : public RpcServiceRequest {
+public:
+	DetachPolicy2ApprovalProcessRequest();
+	~DetachPolicy2ApprovalProcessRequest();
+	std::string getPolicyType() const;
+	void setPolicyType(const std::string &policyType);
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getProcessId() const;
+	void setProcessId(const std::string &processId);
+
+private:
+	std::string policyType_;
+	std::string sourceIp_;
+	std::string policyId_;
+	std::string processId_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_DETACHPOLICY2APPROVALPROCESSREQUEST_H_

csas/include/alibabacloud/csas/model/DetachPolicy2ApprovalProcessResult.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_CSAS_MODEL_DETACHPOLICY2APPROVALPROCESSRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_DETACHPOLICY2APPROVALPROCESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT DetachPolicy2ApprovalProcessResult : public ServiceResult
+			{
+			public:
+
+
+				DetachPolicy2ApprovalProcessResult();
+				explicit DetachPolicy2ApprovalProcessResult(const std::string &payload);
+				~DetachPolicy2ApprovalProcessResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_DETACHPOLICY2APPROVALPROCESSRESULT_H_

csas/include/alibabacloud/csas/model/GetApprovalProcessRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_CSAS_MODEL_GETAPPROVALPROCESSREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_GETAPPROVALPROCESSREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT GetApprovalProcessRequest : public RpcServiceRequest {
+public:
+	GetApprovalProcessRequest();
+	~GetApprovalProcessRequest();
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::string getProcessId() const;
+	void setProcessId(const std::string &processId);
+
+private:
+	std::string sourceIp_;
+	std::string processId_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_GETAPPROVALPROCESSREQUEST_H_

csas/include/alibabacloud/csas/model/GetApprovalProcessResult.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_CSAS_MODEL_GETAPPROVALPROCESSRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_GETAPPROVALPROCESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT GetApprovalProcessResult : public ServiceResult
+			{
+			public:
+
+
+				GetApprovalProcessResult();
+				explicit GetApprovalProcessResult(const std::string &payload);
+				~GetApprovalProcessResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_GETAPPROVALPROCESSRESULT_H_

csas/include/alibabacloud/csas/model/GetApprovalRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_CSAS_MODEL_GETAPPROVALREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_GETAPPROVALREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT GetApprovalRequest : public RpcServiceRequest {
+public:
+	GetApprovalRequest();
+	~GetApprovalRequest();
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::string getApprovalId() const;
+	void setApprovalId(const std::string &approvalId);
+
+private:
+	std::string sourceIp_;
+	std::string approvalId_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_GETAPPROVALREQUEST_H_

csas/include/alibabacloud/csas/model/GetApprovalResult.h

@@ -0,0 +1,85 @@
+/*
+ * 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_CSAS_MODEL_GETAPPROVALRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_GETAPPROVALRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT GetApprovalResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ApprovalProgressesItem
+					{
+						struct OperatorsItem
+						{
+							std::string username;
+							std::string saseUserId;
+						};
+						std::string status;
+						std::string comment;
+						std::vector<ApprovalProgressesItem::OperatorsItem> operators;
+						std::string action;
+						std::string executor;
+						long timestamp;
+					};
+					std::string status;
+					std::string policyType;
+					std::string processName;
+					std::vector<Data::ApprovalProgressesItem> approvalProgresses;
+					std::string createTime;
+					std::string approvalId;
+					long endTimestamp;
+					std::string creatorUsername;
+					std::string approvalDetail;
+					std::string schemaContent;
+					std::string reason;
+					std::string schemaId;
+					std::string processId;
+					std::string creatorUserId;
+					std::string schemaName;
+					std::string creatorDevTag;
+					std::string creatorDepartment;
+				};
+
+
+				GetApprovalResult();
+				explicit GetApprovalResult(const std::string &payload);
+				~GetApprovalResult();
+				std::vector<Data> getApproval()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Data> approval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_GETAPPROVALRESULT_H_

csas/include/alibabacloud/csas/model/GetApprovalSchemaRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_CSAS_MODEL_GETAPPROVALSCHEMAREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_GETAPPROVALSCHEMAREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT GetApprovalSchemaRequest : public RpcServiceRequest {
+public:
+	GetApprovalSchemaRequest();
+	~GetApprovalSchemaRequest();
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::string getSchemaId() const;
+	void setSchemaId(const std::string &schemaId);
+
+private:
+	std::string sourceIp_;
+	std::string schemaId_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_GETAPPROVALSCHEMAREQUEST_H_

csas/include/alibabacloud/csas/model/GetApprovalSchemaResult.h

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

csas/include/alibabacloud/csas/model/GetBootAndAntiUninstallPolicyRequest.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_CSAS_MODEL_GETBOOTANDANTIUNINSTALLPOLICYREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_GETBOOTANDANTIUNINSTALLPOLICYREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT GetBootAndAntiUninstallPolicyRequest : public RpcServiceRequest {
+public:
+	GetBootAndAntiUninstallPolicyRequest();
+	~GetBootAndAntiUninstallPolicyRequest();
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+
+private:
+	std::string sourceIp_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_GETBOOTANDANTIUNINSTALLPOLICYREQUEST_H_

csas/include/alibabacloud/csas/model/GetBootAndAntiUninstallPolicyResult.h

@@ -0,0 +1,83 @@
+/*
+ * 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_CSAS_MODEL_GETBOOTANDANTIUNINSTALLPOLICYRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_GETBOOTANDANTIUNINSTALLPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT GetBootAndAntiUninstallPolicyResult : public ServiceResult
+			{
+			public:
+				struct Strategy
+				{
+					struct BlockContent
+					{
+						struct BlockTextZh
+						{
+							std::string mainButtonText;
+							std::string content;
+							std::string minorButtonText;
+							std::string title;
+						};
+						struct BlockTextEn
+						{
+							std::string mainButtonText;
+							std::string content;
+							std::string minorButtonText;
+							std::string title;
+						};
+						BlockTextZh blockTextZh;
+						BlockTextEn blockTextEn;
+					};
+					bool isAntiUninstall;
+					std::string reportProcessId;
+					std::string createTime;
+					std::vector<std::string> userGroupIds;
+					BlockContent blockContent;
+					std::string updateTime;
+					bool allowReport;
+					bool isBoot;
+					std::string policyId;
+					std::vector<std::string> whitelistUsers;
+				};
+
+
+				GetBootAndAntiUninstallPolicyResult();
+				explicit GetBootAndAntiUninstallPolicyResult(const std::string &payload);
+				~GetBootAndAntiUninstallPolicyResult();
+				Strategy getStrategy()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Strategy strategy_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_GETBOOTANDANTIUNINSTALLPOLICYRESULT_H_

csas/include/alibabacloud/csas/model/GetUserDeviceResult.h

@@ -39,6 +39,11 @@ namespace AlibabaCloud
 						std::string username;
 						std::string saseUserId;
 					};
+					struct NetInterfaceInfoItem
+					{
+						std::string mac;
+						std::string name;
+					};
 					std::string appStatus;
 					std::string dlpStatus;
 					std::string innerIP;
@@ -46,6 +51,7 @@ namespace AlibabaCloud
 					std::string cPU;
 					std::string appVersion;
 					std::string department;
+					std::vector<NetInterfaceInfoItem> netInterfaceInfo;
 					std::string disk;
 					std::string deviceModel;
 					std::string nacStatus;

csas/include/alibabacloud/csas/model/ListApprovalProcessesForApprovalSchemasRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_CSAS_MODEL_LISTAPPROVALPROCESSESFORAPPROVALSCHEMASREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALPROCESSESFORAPPROVALSCHEMASREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT ListApprovalProcessesForApprovalSchemasRequest : public RpcServiceRequest {
+public:
+	ListApprovalProcessesForApprovalSchemasRequest();
+	~ListApprovalProcessesForApprovalSchemasRequest();
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::vector<std::string> getSchemaIds() const;
+	void setSchemaIds(const std::vector<std::string> &schemaIds);
+
+private:
+	std::string sourceIp_;
+	std::vector<std::string> schemaIds_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALPROCESSESFORAPPROVALSCHEMASREQUEST_H_

csas/include/alibabacloud/csas/model/ListApprovalProcessesForApprovalSchemasResult.h

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

csas/include/alibabacloud/csas/model/ListApprovalProcessesRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALPROCESSESREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALPROCESSESREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT ListApprovalProcessesRequest : public RpcServiceRequest {
+public:
+	ListApprovalProcessesRequest();
+	~ListApprovalProcessesRequest();
+	std::vector<std::string> getProcessIds() const;
+	void setProcessIds(const std::vector<std::string> &processIds);
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getSaseUserId() const;
+	void setSaseUserId(const std::string &saseUserId);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	std::string getPolicyType() const;
+	void setPolicyType(const std::string &policyType);
+	std::string getProcessName() const;
+	void setProcessName(const std::string &processName);
+	long getCurrentPage() const;
+	void setCurrentPage(long currentPage);
+	std::string getUsername() const;
+	void setUsername(const std::string &username);
+
+private:
+	std::vector<std::string> processIds_;
+	std::string sourceIp_;
+	std::string policyId_;
+	std::string saseUserId_;
+	long pageSize_;
+	std::string policyType_;
+	std::string processName_;
+	long currentPage_;
+	std::string username_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALPROCESSESREQUEST_H_

csas/include/alibabacloud/csas/model/ListApprovalProcessesResult.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_CSAS_MODEL_LISTAPPROVALPROCESSESRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALPROCESSESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT ListApprovalProcessesResult : public ServiceResult
+			{
+			public:
+
+
+				ListApprovalProcessesResult();
+				explicit ListApprovalProcessesResult(const std::string &payload);
+				~ListApprovalProcessesResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALPROCESSESRESULT_H_

csas/include/alibabacloud/csas/model/ListApprovalSchemasForApprovalProcessesRequest.h

@@ -0,0 +1,45 @@
+/*
+ * 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_CSAS_MODEL_LISTAPPROVALSCHEMASFORAPPROVALPROCESSESREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSCHEMASFORAPPROVALPROCESSESREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT ListApprovalSchemasForApprovalProcessesRequest : public RpcServiceRequest {
+public:
+	ListApprovalSchemasForApprovalProcessesRequest();
+	~ListApprovalSchemasForApprovalProcessesRequest();
+	std::vector<std::string> getProcessIds() const;
+	void setProcessIds(const std::vector<std::string> &processIds);
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+
+private:
+	std::vector<std::string> processIds_;
+	std::string sourceIp_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSCHEMASFORAPPROVALPROCESSESREQUEST_H_

csas/include/alibabacloud/csas/model/ListApprovalSchemasForApprovalProcessesResult.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_CSAS_MODEL_LISTAPPROVALSCHEMASFORAPPROVALPROCESSESRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSCHEMASFORAPPROVALPROCESSESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT ListApprovalSchemasForApprovalProcessesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct SchemasItem
+					{
+						bool isDefault;
+						std::string policyType;
+						std::string description;
+						long schemaVersion;
+						std::string createTime;
+						std::string schemaId;
+						std::string schemaContent;
+						std::string schemaName;
+					};
+					std::string processId;
+					std::vector<Data::SchemasItem> schemas;
+				};
+
+
+				ListApprovalSchemasForApprovalProcessesResult();
+				explicit ListApprovalSchemasForApprovalProcessesResult(const std::string &payload);
+				~ListApprovalSchemasForApprovalProcessesResult();
+				std::vector<Data> getProcesses()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Data> processes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSCHEMASFORAPPROVALPROCESSESRESULT_H_

csas/include/alibabacloud/csas/model/ListApprovalSchemasRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSCHEMASREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSCHEMASREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT ListApprovalSchemasRequest : public RpcServiceRequest {
+public:
+	ListApprovalSchemasRequest();
+	~ListApprovalSchemasRequest();
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::vector<std::string> getSchemaIds() const;
+	void setSchemaIds(const std::vector<std::string> &schemaIds);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	std::string getSchemaName() const;
+	void setSchemaName(const std::string &schemaName);
+	std::string getPolicyType() const;
+	void setPolicyType(const std::string &policyType);
+	long getCurrentPage() const;
+	void setCurrentPage(long currentPage);
+
+private:
+	std::string sourceIp_;
+	std::vector<std::string> schemaIds_;
+	long pageSize_;
+	std::string schemaName_;
+	std::string policyType_;
+	long currentPage_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSCHEMASREQUEST_H_

csas/include/alibabacloud/csas/model/ListApprovalSchemasResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSCHEMASRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSCHEMASRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT ListApprovalSchemasResult : public ServiceResult
+			{
+			public:
+				struct DataList
+				{
+					bool isDefault;
+					std::string policyType;
+					std::string description;
+					long schemaVersion;
+					std::string createTime;
+					std::string schemaId;
+					std::string schemaContent;
+					std::string schemaName;
+				};
+
+
+				ListApprovalSchemasResult();
+				explicit ListApprovalSchemasResult(const std::string &payload);
+				~ListApprovalSchemasResult();
+				std::string getTotalNum()const;
+				std::vector<DataList> getSchemas()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string totalNum_;
+				std::vector<DataList> schemas_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSCHEMASRESULT_H_

csas/include/alibabacloud/csas/model/ListApprovalsRequest.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_CSAS_MODEL_LISTAPPROVALSREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT ListApprovalsRequest : public RpcServiceRequest {
+public:
+	ListApprovalsRequest();
+	~ListApprovalsRequest();
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::string getSchemaId() const;
+	void setSchemaId(const std::string &schemaId);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	long getCreateEndTime() const;
+	void setCreateEndTime(long createEndTime);
+	std::string getOperatorUserId() const;
+	void setOperatorUserId(const std::string &operatorUserId);
+	std::string getSchemaName() const;
+	void setSchemaName(const std::string &schemaName);
+	std::string getPolicyType() const;
+	void setPolicyType(const std::string &policyType);
+	std::string getProcessName() const;
+	void setProcessName(const std::string &processName);
+	long getCurrentPage() const;
+	void setCurrentPage(long currentPage);
+	std::vector<std::string> getApprovalIds() const;
+	void setApprovalIds(const std::vector<std::string> &approvalIds);
+	long getCreateStartTime() const;
+	void setCreateStartTime(long createStartTime);
+	std::string getProcessId() const;
+	void setProcessId(const std::string &processId);
+	std::string getCreatorDepartment() const;
+	void setCreatorDepartment(const std::string &creatorDepartment);
+	std::string getOperatorUsername() const;
+	void setOperatorUsername(const std::string &operatorUsername);
+	std::string getCreatorUserId() const;
+	void setCreatorUserId(const std::string &creatorUserId);
+	std::string getCreatorUsername() const;
+	void setCreatorUsername(const std::string &creatorUsername);
+	std::vector<std::string> getStatuses() const;
+	void setStatuses(const std::vector<std::string> &statuses);
+	std::string getCreatorDevTag() const;
+	void setCreatorDevTag(const std::string &creatorDevTag);
+
+private:
+	std::string sourceIp_;
+	std::string schemaId_;
+	long pageSize_;
+	long createEndTime_;
+	std::string operatorUserId_;
+	std::string schemaName_;
+	std::string policyType_;
+	std::string processName_;
+	long currentPage_;
+	std::vector<std::string> approvalIds_;
+	long createStartTime_;
+	std::string processId_;
+	std::string creatorDepartment_;
+	std::string operatorUsername_;
+	std::string creatorUserId_;
+	std::string creatorUsername_;
+	std::vector<std::string> statuses_;
+	std::string creatorDevTag_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSREQUEST_H_

csas/include/alibabacloud/csas/model/ListApprovalsResult.h

@@ -0,0 +1,87 @@
+/*
+ * 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_CSAS_MODEL_LISTAPPROVALSRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT ListApprovalsResult : public ServiceResult
+			{
+			public:
+				struct DataList
+				{
+					struct ApprovalProgressesItem
+					{
+						struct OperatorsItem
+						{
+							std::string username;
+							std::string saseUserId;
+						};
+						std::string status;
+						std::string comment;
+						std::vector<ApprovalProgressesItem::OperatorsItem> operators;
+						std::string action;
+						std::string executor;
+						long timestamp;
+					};
+					std::string status;
+					std::string policyType;
+					std::string processName;
+					std::vector<DataList::ApprovalProgressesItem> approvalProgresses;
+					std::string createTime;
+					std::string approvalId;
+					long endTimestamp;
+					std::string creatorUsername;
+					std::string approvalDetail;
+					std::string schemaContent;
+					std::string reason;
+					std::string schemaId;
+					std::string processId;
+					std::string creatorUserId;
+					std::string schemaName;
+					std::string creatorDevTag;
+					std::string creatorDepartment;
+				};
+
+
+				ListApprovalsResult();
+				explicit ListApprovalsResult(const std::string &payload);
+				~ListApprovalsResult();
+				std::string getTotalNum()const;
+				std::vector<DataList> getApprovals()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string totalNum_;
+				std::vector<DataList> approvals_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTAPPROVALSRESULT_H_

csas/include/alibabacloud/csas/model/ListUninstallApplicationsRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CSAS_MODEL_LISTUNINSTALLAPPLICATIONSREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTUNINSTALLAPPLICATIONSREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT ListUninstallApplicationsRequest : public RpcServiceRequest {
+public:
+	ListUninstallApplicationsRequest();
+	~ListUninstallApplicationsRequest();
+	std::string getMac() const;
+	void setMac(const std::string &mac);
+	std::string getHostname() const;
+	void setHostname(const std::string &hostname);
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	std::string getDepartment() const;
+	void setDepartment(const std::string &department);
+	long getCurrentPage() const;
+	void setCurrentPage(long currentPage);
+	std::vector<std::string> getApplicationIds() const;
+	void setApplicationIds(const std::vector<std::string> &applicationIds);
+	std::vector<std::string> getStatuses() const;
+	void setStatuses(const std::vector<std::string> &statuses);
+	std::string getUsername() const;
+	void setUsername(const std::string &username);
+
+private:
+	std::string mac_;
+	std::string hostname_;
+	std::string sourceIp_;
+	long pageSize_;
+	std::string department_;
+	long currentPage_;
+	std::vector<std::string> applicationIds_;
+	std::vector<std::string> statuses_;
+	std::string username_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTUNINSTALLAPPLICATIONSREQUEST_H_

csas/include/alibabacloud/csas/model/ListUninstallApplicationsResult.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CSAS_MODEL_LISTUNINSTALLAPPLICATIONSRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTUNINSTALLAPPLICATIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT ListUninstallApplicationsResult : public ServiceResult
+			{
+			public:
+				struct DataList
+				{
+					std::string status;
+					bool isUninstall;
+					std::string devType;
+					std::string createTime;
+					std::string hostname;
+					std::string devTag;
+					std::string saseUserId;
+					std::string mac;
+					std::string reason;
+					std::string department;
+					std::string username;
+					std::string idpName;
+					std::string applicationId;
+				};
+
+
+				ListUninstallApplicationsResult();
+				explicit ListUninstallApplicationsResult(const std::string &payload);
+				~ListUninstallApplicationsResult();
+				long getTotalNum()const;
+				std::vector<DataList> getApplications()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalNum_;
+				std::vector<DataList> applications_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTUNINSTALLAPPLICATIONSRESULT_H_

csas/include/alibabacloud/csas/model/ListUserApplicationsRequest.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_CSAS_MODEL_LISTUSERAPPLICATIONSREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTUSERAPPLICATIONSREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT ListUserApplicationsRequest : public RpcServiceRequest {
+public:
+	ListUserApplicationsRequest();
+	~ListUserApplicationsRequest();
+	int getCurrentPage() const;
+	void setCurrentPage(int currentPage);
+	std::string getSaseUserId() const;
+	void setSaseUserId(const std::string &saseUserId);
+	std::string getName() const;
+	void setName(const std::string &name);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+
+private:
+	int currentPage_;
+	std::string saseUserId_;
+	std::string name_;
+	int pageSize_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTUSERAPPLICATIONSREQUEST_H_

csas/include/alibabacloud/csas/model/ListUserApplicationsResult.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_CSAS_MODEL_LISTUSERAPPLICATIONSRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTUSERAPPLICATIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT ListUserApplicationsResult : public ServiceResult
+			{
+			public:
+				struct ApplicationsItem
+				{
+					struct PortRangesItem
+					{
+						std::string begin;
+						std::string end;
+					};
+					std::vector<std::string> addresses;
+					std::string action;
+					std::vector<ApplicationsItem::PortRangesItem> portRanges;
+					std::string applicationId;
+					std::string protocol;
+					std::string name;
+				};
+
+
+				ListUserApplicationsResult();
+				explicit ListUserApplicationsResult(const std::string &payload);
+				~ListUserApplicationsResult();
+				int getTotalNum()const;
+				std::vector<ApplicationsItem> getApplications()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalNum_;
+				std::vector<ApplicationsItem> applications_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTUSERAPPLICATIONSRESULT_H_

csas/include/alibabacloud/csas/model/ListUserDevicesResult.h

@@ -34,6 +34,11 @@ namespace AlibabaCloud
 			public:
 				struct DataList
 				{
+					struct NetInterfaceInfoItem
+					{
+						std::string mac;
+						std::string name;
+					};
 					std::string appStatus;
 					std::string dlpStatus;
 					std::string innerIP;
@@ -41,6 +46,7 @@ namespace AlibabaCloud
 					std::string cPU;
 					std::string appVersion;
 					std::string department;
+					std::vector<DataList::NetInterfaceInfoItem> netInterfaceInfo;
 					std::string disk;
 					std::string deviceModel;
 					std::string nacStatus;

csas/include/alibabacloud/csas/model/ListUserPrivateAccessPoliciesRequest.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_CSAS_MODEL_LISTUSERPRIVATEACCESSPOLICIESREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTUSERPRIVATEACCESSPOLICIESREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT ListUserPrivateAccessPoliciesRequest : public RpcServiceRequest {
+public:
+	ListUserPrivateAccessPoliciesRequest();
+	~ListUserPrivateAccessPoliciesRequest();
+	int getCurrentPage() const;
+	void setCurrentPage(int currentPage);
+	std::string getSaseUserId() const;
+	void setSaseUserId(const std::string &saseUserId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getName() const;
+	void setName(const std::string &name);
+
+private:
+	int currentPage_;
+	std::string saseUserId_;
+	int pageSize_;
+	std::string name_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTUSERPRIVATEACCESSPOLICIESREQUEST_H_

csas/include/alibabacloud/csas/model/ListUserPrivateAccessPoliciesResult.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CSAS_MODEL_LISTUSERPRIVATEACCESSPOLICIESRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_LISTUSERPRIVATEACCESSPOLICIESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT ListUserPrivateAccessPoliciesResult : public ServiceResult
+			{
+			public:
+				struct Policies
+				{
+					struct CustomUserAttributesItem
+					{
+						std::string relation;
+						int idpId;
+						std::string userGroupType;
+						std::string value;
+					};
+					std::vector<Policies::CustomUserAttributesItem> customUserAttributes;
+					std::string userGroupMode;
+					long priority;
+					std::string deviceAttributeName;
+					std::string policyAction;
+					std::string policyId;
+					std::string name;
+					std::string matchedUserGroup;
+				};
+
+
+				ListUserPrivateAccessPoliciesResult();
+				explicit ListUserPrivateAccessPoliciesResult(const std::string &payload);
+				~ListUserPrivateAccessPoliciesResult();
+				int getTotalNum()const;
+				std::vector<Policies> getPolices()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalNum_;
+				std::vector<Policies> polices_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_LISTUSERPRIVATEACCESSPOLICIESRESULT_H_

csas/include/alibabacloud/csas/model/UpdateApprovalProcessRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CSAS_MODEL_UPDATEAPPROVALPROCESSREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_UPDATEAPPROVALPROCESSREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT UpdateApprovalProcessRequest : public RpcServiceRequest {
+public:
+	struct MatchSchemas {
+		std::string domainBlacklistSchemaId;
+		std::string softwareBlockSchemaId;
+		std::string peripheralBlockSchemaId;
+		std::string deviceRegistrationSchemaId;
+		std::string dlpSendSchemaId;
+		std::string domainWhitelistSchemaId;
+		std::string appUninstallSchemaId;
+	};
+	UpdateApprovalProcessRequest();
+	~UpdateApprovalProcessRequest();
+	std::vector<std::vector<std::string>> getProcessNodes() const;
+	void setProcessNodes(const std::vector<std::vector<std::string>> &processNodes);
+	MatchSchemas getMatchSchemas() const;
+	void setMatchSchemas(const MatchSchemas &matchSchemas);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::string getProcessName() const;
+	void setProcessName(const std::string &processName);
+	std::string getProcessId() const;
+	void setProcessId(const std::string &processId);
+
+private:
+	std::vector<std::vector<std::string>> processNodes_;
+	MatchSchemas matchSchemas_;
+	std::string description_;
+	std::string sourceIp_;
+	std::string processName_;
+	std::string processId_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_UPDATEAPPROVALPROCESSREQUEST_H_

csas/include/alibabacloud/csas/model/UpdateApprovalProcessResult.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_CSAS_MODEL_UPDATEAPPROVALPROCESSRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_UPDATEAPPROVALPROCESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT UpdateApprovalProcessResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateApprovalProcessResult();
+				explicit UpdateApprovalProcessResult(const std::string &payload);
+				~UpdateApprovalProcessResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_UPDATEAPPROVALPROCESSRESULT_H_

csas/include/alibabacloud/csas/model/UpdateApprovalStatusRequest.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_CSAS_MODEL_UPDATEAPPROVALSTATUSREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_UPDATEAPPROVALSTATUSREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT UpdateApprovalStatusRequest : public RpcServiceRequest {
+public:
+	UpdateApprovalStatusRequest();
+	~UpdateApprovalStatusRequest();
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::string getApprovalId() const;
+	void setApprovalId(const std::string &approvalId);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	std::string sourceIp_;
+	std::string approvalId_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_UPDATEAPPROVALSTATUSREQUEST_H_

csas/include/alibabacloud/csas/model/UpdateApprovalStatusResult.h

@@ -0,0 +1,83 @@
+/*
+ * 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_CSAS_MODEL_UPDATEAPPROVALSTATUSRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_UPDATEAPPROVALSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT UpdateApprovalStatusResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct ApprovalProgressesItem
+					{
+						struct OperatorsItem
+						{
+							std::string username;
+							std::string saseUserId;
+						};
+						std::string status;
+						std::string comment;
+						std::vector<ApprovalProgressesItem::OperatorsItem> operators;
+						std::string action;
+						std::string executor;
+						long timestamp;
+					};
+					std::string status;
+					std::string policyType;
+					std::string processName;
+					std::vector<Data::ApprovalProgressesItem> approvalProgresses;
+					std::string createTime;
+					std::string approvalId;
+					long endTimestamp;
+					std::string approvalDetail;
+					std::string schemaContent;
+					std::string reason;
+					std::string schemaId;
+					std::string processId;
+					std::string creatorUserId;
+					std::string schemaName;
+					std::string creatorDevTag;
+				};
+
+
+				UpdateApprovalStatusResult();
+				explicit UpdateApprovalStatusResult(const std::string &payload);
+				~UpdateApprovalStatusResult();
+				std::vector<Data> getApproval()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Data> approval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_UPDATEAPPROVALSTATUSRESULT_H_

csas/include/alibabacloud/csas/model/UpdateBootAndAntiUninstallPolicyRequest.h

@@ -0,0 +1,76 @@
+/*
+ * 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_CSAS_MODEL_UPDATEBOOTANDANTIUNINSTALLPOLICYREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_UPDATEBOOTANDANTIUNINSTALLPOLICYREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT UpdateBootAndAntiUninstallPolicyRequest : public RpcServiceRequest {
+public:
+	struct BlockContent {
+		struct BlockTextZh {
+			std::string minorButtonText;
+			std::string mainButtonText;
+			std::string title;
+			std::string content;
+		};
+		BlockTextZh blockTextZh;
+		struct BlockTextEn {
+			std::string minorButtonText;
+			std::string mainButtonText;
+			std::string title;
+			std::string content;
+		};
+		BlockTextEn blockTextEn;
+	};
+	UpdateBootAndAntiUninstallPolicyRequest();
+	~UpdateBootAndAntiUninstallPolicyRequest();
+	bool getIsAntiUninstall() const;
+	void setIsAntiUninstall(bool isAntiUninstall);
+	bool getAllowReport() const;
+	void setAllowReport(bool allowReport);
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::vector<std::string> getUserGroupIds() const;
+	void setUserGroupIds(const std::vector<std::string> &userGroupIds);
+	std::vector<std::string> getWhitelistUsers() const;
+	void setWhitelistUsers(const std::vector<std::string> &whitelistUsers);
+	BlockContent getBlockContent() const;
+	void setBlockContent(const BlockContent &blockContent);
+	bool getIsBoot() const;
+	void setIsBoot(bool isBoot);
+
+private:
+	bool isAntiUninstall_;
+	bool allowReport_;
+	std::string sourceIp_;
+	std::vector<std::string> userGroupIds_;
+	std::vector<std::string> whitelistUsers_;
+	BlockContent blockContent_;
+	bool isBoot_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_UPDATEBOOTANDANTIUNINSTALLPOLICYREQUEST_H_

csas/include/alibabacloud/csas/model/UpdateBootAndAntiUninstallPolicyResult.h

@@ -0,0 +1,83 @@
+/*
+ * 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_CSAS_MODEL_UPDATEBOOTANDANTIUNINSTALLPOLICYRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_UPDATEBOOTANDANTIUNINSTALLPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT UpdateBootAndAntiUninstallPolicyResult : public ServiceResult
+			{
+			public:
+				struct Strategy
+				{
+					struct BlockContent
+					{
+						struct BlockTextZh
+						{
+							std::string mainButtonText;
+							std::string content;
+							std::string minorButtonText;
+							std::string title;
+						};
+						struct BlockTextEn
+						{
+							std::string mainButtonText;
+							std::string content;
+							std::string minorButtonText;
+							std::string title;
+						};
+						BlockTextZh blockTextZh;
+						BlockTextEn blockTextEn;
+					};
+					bool isAntiUninstall;
+					std::string reportProcessId;
+					std::string createTime;
+					std::vector<std::string> userGroupIds;
+					BlockContent blockContent;
+					std::string updateTime;
+					bool allowReport;
+					bool isBoot;
+					std::string policyId;
+					std::vector<std::string> whitelistUsers;
+				};
+
+
+				UpdateBootAndAntiUninstallPolicyResult();
+				explicit UpdateBootAndAntiUninstallPolicyResult(const std::string &payload);
+				~UpdateBootAndAntiUninstallPolicyResult();
+				Strategy getStrategy()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Strategy strategy_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_UPDATEBOOTANDANTIUNINSTALLPOLICYRESULT_H_

csas/include/alibabacloud/csas/model/UpdateUninstallApplicationsStatusRequest.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_CSAS_MODEL_UPDATEUNINSTALLAPPLICATIONSSTATUSREQUEST_H_
+#define ALIBABACLOUD_CSAS_MODEL_UPDATEUNINSTALLAPPLICATIONSSTATUSREQUEST_H_
+
+#include <alibabacloud/csas/CsasExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Csas {
+namespace Model {
+class ALIBABACLOUD_CSAS_EXPORT UpdateUninstallApplicationsStatusRequest : public RpcServiceRequest {
+public:
+	UpdateUninstallApplicationsStatusRequest();
+	~UpdateUninstallApplicationsStatusRequest();
+	std::vector<std::string> getApplicationIds() const;
+	void setApplicationIds(const std::vector<std::string> &applicationIds);
+	std::string getSourceIp() const;
+	void setSourceIp(const std::string &sourceIp);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	std::vector<std::string> applicationIds_;
+	std::string sourceIp_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Csas
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CSAS_MODEL_UPDATEUNINSTALLAPPLICATIONSSTATUSREQUEST_H_

csas/include/alibabacloud/csas/model/UpdateUninstallApplicationsStatusResult.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_CSAS_MODEL_UPDATEUNINSTALLAPPLICATIONSSTATUSRESULT_H_
+#define ALIBABACLOUD_CSAS_MODEL_UPDATEUNINSTALLAPPLICATIONSSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/csas/CsasExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Csas
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CSAS_EXPORT UpdateUninstallApplicationsStatusResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string status;
+					bool isUninstall;
+					std::string devType;
+					std::string createTime;
+					std::string hostname;
+					std::string devTag;
+					std::string saseUserId;
+					std::string mac;
+					std::string reason;
+					std::string department;
+					std::string username;
+					std::string idpName;
+					std::string applicationId;
+				};
+
+
+				UpdateUninstallApplicationsStatusResult();
+				explicit UpdateUninstallApplicationsStatusResult(const std::string &payload);
+				~UpdateUninstallApplicationsStatusResult();
+				std::vector<Data> getApplications()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Data> applications_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CSAS_MODEL_UPDATEUNINSTALLAPPLICATIONSSTATUSRESULT_H_

csas/include/alibabacloud/csas/model/UpdateUserDevicesSharingStatusResult.h

@@ -34,6 +34,11 @@ namespace AlibabaCloud
 			public:
 				struct Data
 				{
+					struct NetInterfaceInfoItem
+					{
+						std::string mac;
+						std::string name;
+					};
 					std::string appStatus;
 					std::string dlpStatus;
 					std::string innerIP;
@@ -41,6 +46,7 @@ namespace AlibabaCloud
 					std::string cPU;
 					std::string appVersion;
 					std::string department;
+					std::vector<Data::NetInterfaceInfoItem> netInterfaceInfo;
 					std::string disk;
 					std::string deviceModel;
 					std::string nacStatus;

csas/include/alibabacloud/csas/model/UpdateUserDevicesStatusResult.h

@@ -34,6 +34,11 @@ namespace AlibabaCloud
 			public:
 				struct Data
 				{
+					struct NetInterfaceInfoItem
+					{
+						std::string mac;
+						std::string name;
+					};
 					std::string appStatus;
 					std::string dlpStatus;
 					std::string innerIP;
@@ -41,6 +46,7 @@ namespace AlibabaCloud
 					std::string cPU;
 					std::string appVersion;
 					std::string department;
+					std::vector<Data::NetInterfaceInfoItem> netInterfaceInfo;
 					std::string disk;
 					std::string deviceModel;
 					std::string nacStatus;

csas/src/CsasClient.cc

@@ -87,6 +87,78 @@ CsasClient::AttachApplication2ConnectorOutcomeCallable CsasClient::attachApplica
 	return task->get_future();
 }
 
+CsasClient::AttachPolicy2ApprovalProcessOutcome CsasClient::attachPolicy2ApprovalProcess(const AttachPolicy2ApprovalProcessRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AttachPolicy2ApprovalProcessOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AttachPolicy2ApprovalProcessOutcome(AttachPolicy2ApprovalProcessResult(outcome.result()));
+	else
+		return AttachPolicy2ApprovalProcessOutcome(outcome.error());
+}
+
+void CsasClient::attachPolicy2ApprovalProcessAsync(const AttachPolicy2ApprovalProcessRequest& request, const AttachPolicy2ApprovalProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, attachPolicy2ApprovalProcess(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::AttachPolicy2ApprovalProcessOutcomeCallable CsasClient::attachPolicy2ApprovalProcessCallable(const AttachPolicy2ApprovalProcessRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AttachPolicy2ApprovalProcessOutcome()>>(
+			[this, request]()
+			{
+			return this->attachPolicy2ApprovalProcess(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CsasClient::CreateApprovalProcessOutcome CsasClient::createApprovalProcess(const CreateApprovalProcessRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateApprovalProcessOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateApprovalProcessOutcome(CreateApprovalProcessResult(outcome.result()));
+	else
+		return CreateApprovalProcessOutcome(outcome.error());
+}
+
+void CsasClient::createApprovalProcessAsync(const CreateApprovalProcessRequest& request, const CreateApprovalProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createApprovalProcess(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::CreateApprovalProcessOutcomeCallable CsasClient::createApprovalProcessCallable(const CreateApprovalProcessRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateApprovalProcessOutcome()>>(
+			[this, request]()
+			{
+			return this->createApprovalProcess(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CsasClient::CreateClientUserOutcome CsasClient::createClientUser(const CreateClientUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -519,6 +591,42 @@ CsasClient::CreateWmInfoMappingOutcomeCallable CsasClient::createWmInfoMappingCa
 	return task->get_future();
 }
 
+CsasClient::DeleteApprovalProcessesOutcome CsasClient::deleteApprovalProcesses(const DeleteApprovalProcessesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteApprovalProcessesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteApprovalProcessesOutcome(DeleteApprovalProcessesResult(outcome.result()));
+	else
+		return DeleteApprovalProcessesOutcome(outcome.error());
+}
+
+void CsasClient::deleteApprovalProcessesAsync(const DeleteApprovalProcessesRequest& request, const DeleteApprovalProcessesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteApprovalProcesses(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::DeleteApprovalProcessesOutcomeCallable CsasClient::deleteApprovalProcessesCallable(const DeleteApprovalProcessesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteApprovalProcessesOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteApprovalProcesses(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CsasClient::DeleteClientUserOutcome CsasClient::deleteClientUser(const DeleteClientUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -879,6 +987,42 @@ CsasClient::DetachApplication2ConnectorOutcomeCallable CsasClient::detachApplica
 	return task->get_future();
 }
 
+CsasClient::DetachPolicy2ApprovalProcessOutcome CsasClient::detachPolicy2ApprovalProcess(const DetachPolicy2ApprovalProcessRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetachPolicy2ApprovalProcessOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetachPolicy2ApprovalProcessOutcome(DetachPolicy2ApprovalProcessResult(outcome.result()));
+	else
+		return DetachPolicy2ApprovalProcessOutcome(outcome.error());
+}
+
+void CsasClient::detachPolicy2ApprovalProcessAsync(const DetachPolicy2ApprovalProcessRequest& request, const DetachPolicy2ApprovalProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detachPolicy2ApprovalProcess(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::DetachPolicy2ApprovalProcessOutcomeCallable CsasClient::detachPolicy2ApprovalProcessCallable(const DetachPolicy2ApprovalProcessRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetachPolicy2ApprovalProcessOutcome()>>(
+			[this, request]()
+			{
+			return this->detachPolicy2ApprovalProcess(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CsasClient::ExportUserDevicesOutcome CsasClient::exportUserDevices(const ExportUserDevicesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -951,6 +1095,150 @@ CsasClient::GetActiveIdpConfigOutcomeCallable CsasClient::getActiveIdpConfigCall
 	return task->get_future();
 }
 
+CsasClient::GetApprovalOutcome CsasClient::getApproval(const GetApprovalRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetApprovalOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetApprovalOutcome(GetApprovalResult(outcome.result()));
+	else
+		return GetApprovalOutcome(outcome.error());
+}
+
+void CsasClient::getApprovalAsync(const GetApprovalRequest& request, const GetApprovalAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getApproval(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::GetApprovalOutcomeCallable CsasClient::getApprovalCallable(const GetApprovalRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetApprovalOutcome()>>(
+			[this, request]()
+			{
+			return this->getApproval(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CsasClient::GetApprovalProcessOutcome CsasClient::getApprovalProcess(const GetApprovalProcessRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetApprovalProcessOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetApprovalProcessOutcome(GetApprovalProcessResult(outcome.result()));
+	else
+		return GetApprovalProcessOutcome(outcome.error());
+}
+
+void CsasClient::getApprovalProcessAsync(const GetApprovalProcessRequest& request, const GetApprovalProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getApprovalProcess(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::GetApprovalProcessOutcomeCallable CsasClient::getApprovalProcessCallable(const GetApprovalProcessRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetApprovalProcessOutcome()>>(
+			[this, request]()
+			{
+			return this->getApprovalProcess(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CsasClient::GetApprovalSchemaOutcome CsasClient::getApprovalSchema(const GetApprovalSchemaRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetApprovalSchemaOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetApprovalSchemaOutcome(GetApprovalSchemaResult(outcome.result()));
+	else
+		return GetApprovalSchemaOutcome(outcome.error());
+}
+
+void CsasClient::getApprovalSchemaAsync(const GetApprovalSchemaRequest& request, const GetApprovalSchemaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getApprovalSchema(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::GetApprovalSchemaOutcomeCallable CsasClient::getApprovalSchemaCallable(const GetApprovalSchemaRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetApprovalSchemaOutcome()>>(
+			[this, request]()
+			{
+			return this->getApprovalSchema(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CsasClient::GetBootAndAntiUninstallPolicyOutcome CsasClient::getBootAndAntiUninstallPolicy(const GetBootAndAntiUninstallPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetBootAndAntiUninstallPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetBootAndAntiUninstallPolicyOutcome(GetBootAndAntiUninstallPolicyResult(outcome.result()));
+	else
+		return GetBootAndAntiUninstallPolicyOutcome(outcome.error());
+}
+
+void CsasClient::getBootAndAntiUninstallPolicyAsync(const GetBootAndAntiUninstallPolicyRequest& request, const GetBootAndAntiUninstallPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getBootAndAntiUninstallPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::GetBootAndAntiUninstallPolicyOutcomeCallable CsasClient::getBootAndAntiUninstallPolicyCallable(const GetBootAndAntiUninstallPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetBootAndAntiUninstallPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->getBootAndAntiUninstallPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CsasClient::GetClientUserOutcome CsasClient::getClientUser(const GetClientUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1383,6 +1671,186 @@ CsasClient::ListApplicationsForPrivateAccessTagOutcomeCallable CsasClient::listA
 	return task->get_future();
 }
 
+CsasClient::ListApprovalProcessesOutcome CsasClient::listApprovalProcesses(const ListApprovalProcessesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListApprovalProcessesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListApprovalProcessesOutcome(ListApprovalProcessesResult(outcome.result()));
+	else
+		return ListApprovalProcessesOutcome(outcome.error());
+}
+
+void CsasClient::listApprovalProcessesAsync(const ListApprovalProcessesRequest& request, const ListApprovalProcessesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listApprovalProcesses(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::ListApprovalProcessesOutcomeCallable CsasClient::listApprovalProcessesCallable(const ListApprovalProcessesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListApprovalProcessesOutcome()>>(
+			[this, request]()
+			{
+			return this->listApprovalProcesses(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CsasClient::ListApprovalProcessesForApprovalSchemasOutcome CsasClient::listApprovalProcessesForApprovalSchemas(const ListApprovalProcessesForApprovalSchemasRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListApprovalProcessesForApprovalSchemasOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListApprovalProcessesForApprovalSchemasOutcome(ListApprovalProcessesForApprovalSchemasResult(outcome.result()));
+	else
+		return ListApprovalProcessesForApprovalSchemasOutcome(outcome.error());
+}
+
+void CsasClient::listApprovalProcessesForApprovalSchemasAsync(const ListApprovalProcessesForApprovalSchemasRequest& request, const ListApprovalProcessesForApprovalSchemasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listApprovalProcessesForApprovalSchemas(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::ListApprovalProcessesForApprovalSchemasOutcomeCallable CsasClient::listApprovalProcessesForApprovalSchemasCallable(const ListApprovalProcessesForApprovalSchemasRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListApprovalProcessesForApprovalSchemasOutcome()>>(
+			[this, request]()
+			{
+			return this->listApprovalProcessesForApprovalSchemas(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CsasClient::ListApprovalSchemasOutcome CsasClient::listApprovalSchemas(const ListApprovalSchemasRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListApprovalSchemasOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListApprovalSchemasOutcome(ListApprovalSchemasResult(outcome.result()));
+	else
+		return ListApprovalSchemasOutcome(outcome.error());
+}
+
+void CsasClient::listApprovalSchemasAsync(const ListApprovalSchemasRequest& request, const ListApprovalSchemasAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listApprovalSchemas(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::ListApprovalSchemasOutcomeCallable CsasClient::listApprovalSchemasCallable(const ListApprovalSchemasRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListApprovalSchemasOutcome()>>(
+			[this, request]()
+			{
+			return this->listApprovalSchemas(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CsasClient::ListApprovalSchemasForApprovalProcessesOutcome CsasClient::listApprovalSchemasForApprovalProcesses(const ListApprovalSchemasForApprovalProcessesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListApprovalSchemasForApprovalProcessesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListApprovalSchemasForApprovalProcessesOutcome(ListApprovalSchemasForApprovalProcessesResult(outcome.result()));
+	else
+		return ListApprovalSchemasForApprovalProcessesOutcome(outcome.error());
+}
+
+void CsasClient::listApprovalSchemasForApprovalProcessesAsync(const ListApprovalSchemasForApprovalProcessesRequest& request, const ListApprovalSchemasForApprovalProcessesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listApprovalSchemasForApprovalProcesses(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::ListApprovalSchemasForApprovalProcessesOutcomeCallable CsasClient::listApprovalSchemasForApprovalProcessesCallable(const ListApprovalSchemasForApprovalProcessesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListApprovalSchemasForApprovalProcessesOutcome()>>(
+			[this, request]()
+			{
+			return this->listApprovalSchemasForApprovalProcesses(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CsasClient::ListApprovalsOutcome CsasClient::listApprovals(const ListApprovalsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListApprovalsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListApprovalsOutcome(ListApprovalsResult(outcome.result()));
+	else
+		return ListApprovalsOutcome(outcome.error());
+}
+
+void CsasClient::listApprovalsAsync(const ListApprovalsRequest& request, const ListApprovalsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listApprovals(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::ListApprovalsOutcomeCallable CsasClient::listApprovalsCallable(const ListApprovalsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListApprovalsOutcome()>>(
+			[this, request]()
+			{
+			return this->listApprovals(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CsasClient::ListClientUsersOutcome CsasClient::listClientUsers(const ListClientUsersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2175,6 +2643,78 @@ CsasClient::ListTagsForPrivateAccessPolicyOutcomeCallable CsasClient::listTagsFo
 	return task->get_future();
 }
 
+CsasClient::ListUninstallApplicationsOutcome CsasClient::listUninstallApplications(const ListUninstallApplicationsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListUninstallApplicationsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListUninstallApplicationsOutcome(ListUninstallApplicationsResult(outcome.result()));
+	else
+		return ListUninstallApplicationsOutcome(outcome.error());
+}
+
+void CsasClient::listUninstallApplicationsAsync(const ListUninstallApplicationsRequest& request, const ListUninstallApplicationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listUninstallApplications(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::ListUninstallApplicationsOutcomeCallable CsasClient::listUninstallApplicationsCallable(const ListUninstallApplicationsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListUninstallApplicationsOutcome()>>(
+			[this, request]()
+			{
+			return this->listUninstallApplications(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CsasClient::ListUserApplicationsOutcome CsasClient::listUserApplications(const ListUserApplicationsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListUserApplicationsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListUserApplicationsOutcome(ListUserApplicationsResult(outcome.result()));
+	else
+		return ListUserApplicationsOutcome(outcome.error());
+}
+
+void CsasClient::listUserApplicationsAsync(const ListUserApplicationsRequest& request, const ListUserApplicationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listUserApplications(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::ListUserApplicationsOutcomeCallable CsasClient::listUserApplicationsCallable(const ListUserApplicationsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListUserApplicationsOutcome()>>(
+			[this, request]()
+			{
+			return this->listUserApplications(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CsasClient::ListUserDevicesOutcome CsasClient::listUserDevices(const ListUserDevicesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2319,6 +2859,42 @@ CsasClient::ListUserGroupsForRegistrationPolicyOutcomeCallable CsasClient::listU
 	return task->get_future();
 }
 
+CsasClient::ListUserPrivateAccessPoliciesOutcome CsasClient::listUserPrivateAccessPolicies(const ListUserPrivateAccessPoliciesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListUserPrivateAccessPoliciesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListUserPrivateAccessPoliciesOutcome(ListUserPrivateAccessPoliciesResult(outcome.result()));
+	else
+		return ListUserPrivateAccessPoliciesOutcome(outcome.error());
+}
+
+void CsasClient::listUserPrivateAccessPoliciesAsync(const ListUserPrivateAccessPoliciesRequest& request, const ListUserPrivateAccessPoliciesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listUserPrivateAccessPolicies(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::ListUserPrivateAccessPoliciesOutcomeCallable CsasClient::listUserPrivateAccessPoliciesCallable(const ListUserPrivateAccessPoliciesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListUserPrivateAccessPoliciesOutcome()>>(
+			[this, request]()
+			{
+			return this->listUserPrivateAccessPolicies(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CsasClient::ListUsersOutcome CsasClient::listUsers(const ListUsersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2427,6 +3003,114 @@ CsasClient::RevokeUserSessionOutcomeCallable CsasClient::revokeUserSessionCallab
 	return task->get_future();
 }
 
+CsasClient::UpdateApprovalProcessOutcome CsasClient::updateApprovalProcess(const UpdateApprovalProcessRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateApprovalProcessOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateApprovalProcessOutcome(UpdateApprovalProcessResult(outcome.result()));
+	else
+		return UpdateApprovalProcessOutcome(outcome.error());
+}
+
+void CsasClient::updateApprovalProcessAsync(const UpdateApprovalProcessRequest& request, const UpdateApprovalProcessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateApprovalProcess(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::UpdateApprovalProcessOutcomeCallable CsasClient::updateApprovalProcessCallable(const UpdateApprovalProcessRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateApprovalProcessOutcome()>>(
+			[this, request]()
+			{
+			return this->updateApprovalProcess(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CsasClient::UpdateApprovalStatusOutcome CsasClient::updateApprovalStatus(const UpdateApprovalStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateApprovalStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateApprovalStatusOutcome(UpdateApprovalStatusResult(outcome.result()));
+	else
+		return UpdateApprovalStatusOutcome(outcome.error());
+}
+
+void CsasClient::updateApprovalStatusAsync(const UpdateApprovalStatusRequest& request, const UpdateApprovalStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateApprovalStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::UpdateApprovalStatusOutcomeCallable CsasClient::updateApprovalStatusCallable(const UpdateApprovalStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateApprovalStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->updateApprovalStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CsasClient::UpdateBootAndAntiUninstallPolicyOutcome CsasClient::updateBootAndAntiUninstallPolicy(const UpdateBootAndAntiUninstallPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateBootAndAntiUninstallPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateBootAndAntiUninstallPolicyOutcome(UpdateBootAndAntiUninstallPolicyResult(outcome.result()));
+	else
+		return UpdateBootAndAntiUninstallPolicyOutcome(outcome.error());
+}
+
+void CsasClient::updateBootAndAntiUninstallPolicyAsync(const UpdateBootAndAntiUninstallPolicyRequest& request, const UpdateBootAndAntiUninstallPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateBootAndAntiUninstallPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::UpdateBootAndAntiUninstallPolicyOutcomeCallable CsasClient::updateBootAndAntiUninstallPolicyCallable(const UpdateBootAndAntiUninstallPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateBootAndAntiUninstallPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->updateBootAndAntiUninstallPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CsasClient::UpdateClientUserOutcome CsasClient::updateClientUser(const UpdateClientUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2787,6 +3471,42 @@ CsasClient::UpdateRegistrationPolicyOutcomeCallable CsasClient::updateRegistrati
 	return task->get_future();
 }
 
+CsasClient::UpdateUninstallApplicationsStatusOutcome CsasClient::updateUninstallApplicationsStatus(const UpdateUninstallApplicationsStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateUninstallApplicationsStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateUninstallApplicationsStatusOutcome(UpdateUninstallApplicationsStatusResult(outcome.result()));
+	else
+		return UpdateUninstallApplicationsStatusOutcome(outcome.error());
+}
+
+void CsasClient::updateUninstallApplicationsStatusAsync(const UpdateUninstallApplicationsStatusRequest& request, const UpdateUninstallApplicationsStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateUninstallApplicationsStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CsasClient::UpdateUninstallApplicationsStatusOutcomeCallable CsasClient::updateUninstallApplicationsStatusCallable(const UpdateUninstallApplicationsStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateUninstallApplicationsStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->updateUninstallApplicationsStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CsasClient::UpdateUserDevicesSharingStatusOutcome CsasClient::updateUserDevicesSharingStatus(const UpdateUserDevicesSharingStatusRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

csas/src/model/AttachPolicy2ApprovalProcessRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/csas/model/AttachPolicy2ApprovalProcessRequest.h>
+
+using AlibabaCloud::Csas::Model::AttachPolicy2ApprovalProcessRequest;
+
+AttachPolicy2ApprovalProcessRequest::AttachPolicy2ApprovalProcessRequest()
+    : RpcServiceRequest("csas", "2023-01-20", "AttachPolicy2ApprovalProcess") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AttachPolicy2ApprovalProcessRequest::~AttachPolicy2ApprovalProcessRequest() {}
+
+std::string AttachPolicy2ApprovalProcessRequest::getPolicyType() const {
+  return policyType_;
+}
+
+void AttachPolicy2ApprovalProcessRequest::setPolicyType(const std::string &policyType) {
+  policyType_ = policyType;
+  setBodyParameter(std::string("PolicyType"), policyType);
+}
+
+std::string AttachPolicy2ApprovalProcessRequest::getSourceIp() const {
+  return sourceIp_;
+}
+
+void AttachPolicy2ApprovalProcessRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
+}
+
+std::string AttachPolicy2ApprovalProcessRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void AttachPolicy2ApprovalProcessRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setBodyParameter(std::string("PolicyId"), policyId);
+}
+
+std::string AttachPolicy2ApprovalProcessRequest::getProcessId() const {
+  return processId_;
+}
+
+void AttachPolicy2ApprovalProcessRequest::setProcessId(const std::string &processId) {
+  processId_ = processId;
+  setBodyParameter(std::string("ProcessId"), processId);
+}
+

csas/src/model/AttachPolicy2ApprovalProcessResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/polardb/model/UpgradeDBClusterMinorVersionResult.h>
+#include <alibabacloud/csas/model/AttachPolicy2ApprovalProcessResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::Polardb;
-using namespace AlibabaCloud::Polardb::Model;
+using namespace AlibabaCloud::Csas;
+using namespace AlibabaCloud::Csas::Model;
 
-UpgradeDBClusterMinorVersionResult::UpgradeDBClusterMinorVersionResult() :
+AttachPolicy2ApprovalProcessResult::AttachPolicy2ApprovalProcessResult() :
 	ServiceResult()
 {}
 
-UpgradeDBClusterMinorVersionResult::UpgradeDBClusterMinorVersionResult(const std::string &payload) :
+AttachPolicy2ApprovalProcessResult::AttachPolicy2ApprovalProcessResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-UpgradeDBClusterMinorVersionResult::~UpgradeDBClusterMinorVersionResult()
+AttachPolicy2ApprovalProcessResult::~AttachPolicy2ApprovalProcessResult()
 {}
 
-void UpgradeDBClusterMinorVersionResult::parse(const std::string &payload)
+void AttachPolicy2ApprovalProcessResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

csas/src/model/CreateApprovalProcessRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * 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/csas/model/CreateApprovalProcessRequest.h>
+
+using AlibabaCloud::Csas::Model::CreateApprovalProcessRequest;
+
+CreateApprovalProcessRequest::CreateApprovalProcessRequest()
+    : RpcServiceRequest("csas", "2023-01-20", "CreateApprovalProcess") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateApprovalProcessRequest::~CreateApprovalProcessRequest() {}
+
+std::vector<CreateApprovalProcessRequest::std::vector<std::string>> CreateApprovalProcessRequest::getProcessNodes() const {
+  return processNodes_;
+}
+
+void CreateApprovalProcessRequest::setProcessNodes(const std::vector<CreateApprovalProcessRequest::std::vector<std::string>> &processNodes) {
+  processNodes_ = processNodes;
+  for(int dep1 = 0; dep1 != processNodes.size(); dep1++) {
+    for(int dep2 = 0; dep2 != processNodes[dep1].size(); dep2++) {
+      setBodyParameter(std::string("ProcessNodes") + "." + std::to_string(dep1 + 1) + "." + std::to_string(dep2 + 1), processNodes[dep1][dep2]);
+    }
+  }
+}
+
+CreateApprovalProcessRequest::MatchSchemas CreateApprovalProcessRequest::getMatchSchemas() const {
+  return matchSchemas_;
+}
+
+void CreateApprovalProcessRequest::setMatchSchemas(const CreateApprovalProcessRequest::MatchSchemas &matchSchemas) {
+  matchSchemas_ = matchSchemas;
+  setBodyParameter(std::string("MatchSchemas") + ".DomainBlacklistSchemaId", matchSchemas.domainBlacklistSchemaId);
+  setBodyParameter(std::string("MatchSchemas") + ".SoftwareBlockSchemaId", matchSchemas.softwareBlockSchemaId);
+  setBodyParameter(std::string("MatchSchemas") + ".PeripheralBlockSchemaId", matchSchemas.peripheralBlockSchemaId);
+  setBodyParameter(std::string("MatchSchemas") + ".DeviceRegistrationSchemaId", matchSchemas.deviceRegistrationSchemaId);
+  setBodyParameter(std::string("MatchSchemas") + ".DlpSendSchemaId", matchSchemas.dlpSendSchemaId);
+  setBodyParameter(std::string("MatchSchemas") + ".DomainWhitelistSchemaId", matchSchemas.domainWhitelistSchemaId);
+  setBodyParameter(std::string("MatchSchemas") + ".AppUninstallSchemaId", matchSchemas.appUninstallSchemaId);
+}
+
+std::string CreateApprovalProcessRequest::getProcessName() const {
+  return processName_;
+}
+
+void CreateApprovalProcessRequest::setProcessName(const std::string &processName) {
+  processName_ = processName;
+  setBodyParameter(std::string("ProcessName"), processName);
+}
+
+std::string CreateApprovalProcessRequest::getDescription() const {
+  return description_;
+}
+
+void CreateApprovalProcessRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setBodyParameter(std::string("Description"), description);
+}
+
+std::string CreateApprovalProcessRequest::getSourceIp() const {
+  return sourceIp_;
+}
+
+void CreateApprovalProcessRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
+}
+

csas/src/model/CreateApprovalProcessResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/paifeaturestore/model/ChangeProjectFeatureEntityHotIdVersionResult.h>
+#include <alibabacloud/csas/model/CreateApprovalProcessResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::PaiFeatureStore;
-using namespace AlibabaCloud::PaiFeatureStore::Model;
+using namespace AlibabaCloud::Csas;
+using namespace AlibabaCloud::Csas::Model;
 
-ChangeProjectFeatureEntityHotIdVersionResult::ChangeProjectFeatureEntityHotIdVersionResult() :
+CreateApprovalProcessResult::CreateApprovalProcessResult() :
 	ServiceResult()
 {}
 
-ChangeProjectFeatureEntityHotIdVersionResult::ChangeProjectFeatureEntityHotIdVersionResult(const std::string &payload) :
+CreateApprovalProcessResult::CreateApprovalProcessResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-ChangeProjectFeatureEntityHotIdVersionResult::~ChangeProjectFeatureEntityHotIdVersionResult()
+CreateApprovalProcessResult::~CreateApprovalProcessResult()
 {}
 
-void ChangeProjectFeatureEntityHotIdVersionResult::parse(const std::string &payload)
+void CreateApprovalProcessResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

csas/src/model/DeleteApprovalProcessesRequest.cc

@@ -0,0 +1,47 @@
+/*
+ * 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/csas/model/DeleteApprovalProcessesRequest.h>
+
+using AlibabaCloud::Csas::Model::DeleteApprovalProcessesRequest;
+
+DeleteApprovalProcessesRequest::DeleteApprovalProcessesRequest()
+    : RpcServiceRequest("csas", "2023-01-20", "DeleteApprovalProcesses") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteApprovalProcessesRequest::~DeleteApprovalProcessesRequest() {}
+
+std::vector<DeleteApprovalProcessesRequest::std::string> DeleteApprovalProcessesRequest::getProcessIds() const {
+  return processIds_;
+}
+
+void DeleteApprovalProcessesRequest::setProcessIds(const std::vector<DeleteApprovalProcessesRequest::std::string> &processIds) {
+  processIds_ = processIds;
+  for(int dep1 = 0; dep1 != processIds.size(); dep1++) {
+    setBodyParameter(std::string("ProcessIds") + "." + std::to_string(dep1 + 1), processIds[dep1]);
+  }
+}
+
+std::string DeleteApprovalProcessesRequest::getSourceIp() const {
+  return sourceIp_;
+}
+
+void DeleteApprovalProcessesRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
+}
+

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

csas/src/model/DetachPolicy2ApprovalProcessRequest.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/csas/model/DetachPolicy2ApprovalProcessRequest.h>
+
+using AlibabaCloud::Csas::Model::DetachPolicy2ApprovalProcessRequest;
+
+DetachPolicy2ApprovalProcessRequest::DetachPolicy2ApprovalProcessRequest()
+    : RpcServiceRequest("csas", "2023-01-20", "DetachPolicy2ApprovalProcess") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DetachPolicy2ApprovalProcessRequest::~DetachPolicy2ApprovalProcessRequest() {}
+
+std::string DetachPolicy2ApprovalProcessRequest::getPolicyType() const {
+  return policyType_;
+}
+
+void DetachPolicy2ApprovalProcessRequest::setPolicyType(const std::string &policyType) {
+  policyType_ = policyType;
+  setBodyParameter(std::string("PolicyType"), policyType);
+}
+
+std::string DetachPolicy2ApprovalProcessRequest::getSourceIp() const {
+  return sourceIp_;
+}
+
+void DetachPolicy2ApprovalProcessRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
+}
+
+std::string DetachPolicy2ApprovalProcessRequest::getPolicyId() const {
+  return policyId_;
+}
+
+void DetachPolicy2ApprovalProcessRequest::setPolicyId(const std::string &policyId) {
+  policyId_ = policyId;
+  setBodyParameter(std::string("PolicyId"), policyId);
+}
+
+std::string DetachPolicy2ApprovalProcessRequest::getProcessId() const {
+  return processId_;
+}
+
+void DetachPolicy2ApprovalProcessRequest::setProcessId(const std::string &processId) {
+  processId_ = processId;
+  setBodyParameter(std::string("ProcessId"), processId);
+}
+

csas/src/model/DetachPolicy2ApprovalProcessResult.cc

@@ -14,39 +14,31 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/paifeaturestore/model/ListProjectFeatureViewOwnersResult.h>
+#include <alibabacloud/csas/model/DetachPolicy2ApprovalProcessResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::PaiFeatureStore;
-using namespace AlibabaCloud::PaiFeatureStore::Model;
+using namespace AlibabaCloud::Csas;
+using namespace AlibabaCloud::Csas::Model;
 
-ListProjectFeatureViewOwnersResult::ListProjectFeatureViewOwnersResult() :
+DetachPolicy2ApprovalProcessResult::DetachPolicy2ApprovalProcessResult() :
 	ServiceResult()
 {}
 
-ListProjectFeatureViewOwnersResult::ListProjectFeatureViewOwnersResult(const std::string &payload) :
+DetachPolicy2ApprovalProcessResult::DetachPolicy2ApprovalProcessResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-ListProjectFeatureViewOwnersResult::~ListProjectFeatureViewOwnersResult()
+DetachPolicy2ApprovalProcessResult::~DetachPolicy2ApprovalProcessResult()
 {}
 
-void ListProjectFeatureViewOwnersResult::parse(const std::string &payload)
+void DetachPolicy2ApprovalProcessResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	auto allOwners = value["Owners"]["Owners"];
-	for (const auto &item : allOwners)
-		owners_.push_back(item.asString());
 
 }
 
-std::vector<std::string> ListProjectFeatureViewOwnersResult::getOwners()const
-{
-	return owners_;
-}
-

csas/src/model/GetApprovalProcessRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/csas/model/GetApprovalProcessRequest.h>
+
+using AlibabaCloud::Csas::Model::GetApprovalProcessRequest;
+
+GetApprovalProcessRequest::GetApprovalProcessRequest()
+    : RpcServiceRequest("csas", "2023-01-20", "GetApprovalProcess") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetApprovalProcessRequest::~GetApprovalProcessRequest() {}
+
+std::string GetApprovalProcessRequest::getSourceIp() const {
+  return sourceIp_;
+}
+
+void GetApprovalProcessRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
+}
+
+std::string GetApprovalProcessRequest::getProcessId() const {
+  return processId_;
+}
+
+void GetApprovalProcessRequest::setProcessId(const std::string &processId) {
+  processId_ = processId;
+  setParameter(std::string("ProcessId"), processId);
+}
+

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

csas/src/model/GetApprovalRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * 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/csas/model/GetApprovalRequest.h>
+
+using AlibabaCloud::Csas::Model::GetApprovalRequest;
+
+GetApprovalRequest::GetApprovalRequest()
+    : RpcServiceRequest("csas", "2023-01-20", "GetApproval") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetApprovalRequest::~GetApprovalRequest() {}
+
+std::string GetApprovalRequest::getSourceIp() const {
+  return sourceIp_;
+}
+
+void GetApprovalRequest::setSourceIp(const std::string &sourceIp) {
+  sourceIp_ = sourceIp;
+  setParameter(std::string("SourceIp"), sourceIp);
+}
+
+std::string GetApprovalRequest::getApprovalId() const {
+  return approvalId_;
+}
+
+void GetApprovalRequest::setApprovalId(const std::string &approvalId) {
+  approvalId_ = approvalId;
+  setParameter(std::string("ApprovalId"), approvalId);
+}
+

csas/src/model/GetApprovalResult.cc

@@ -0,0 +1,113 @@
+/*
+ * 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/csas/model/GetApprovalResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Csas;
+using namespace AlibabaCloud::Csas::Model;
+
+GetApprovalResult::GetApprovalResult() :
+	ServiceResult()
+{}
+
+GetApprovalResult::GetApprovalResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetApprovalResult::~GetApprovalResult()
+{}
+
+void GetApprovalResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allApprovalNode = value["Approval"]["data"];
+	for (auto valueApprovaldata : allApprovalNode)
+	{
+		Data approvalObject;
+		if(!valueApprovaldata["ApprovalId"].isNull())
+			approvalObject.approvalId = valueApprovaldata["ApprovalId"].asString();
+		if(!valueApprovaldata["EndTimestamp"].isNull())
+			approvalObject.endTimestamp = std::stol(valueApprovaldata["EndTimestamp"].asString());
+		if(!valueApprovaldata["ApprovalDetail"].isNull())
+			approvalObject.approvalDetail = valueApprovaldata["ApprovalDetail"].asString();
+		if(!valueApprovaldata["Status"].isNull())
+			approvalObject.status = valueApprovaldata["Status"].asString();
+		if(!valueApprovaldata["ProcessId"].isNull())
+			approvalObject.processId = valueApprovaldata["ProcessId"].asString();
+		if(!valueApprovaldata["ProcessName"].isNull())
+			approvalObject.processName = valueApprovaldata["ProcessName"].asString();
+		if(!valueApprovaldata["PolicyType"].isNull())
+			approvalObject.policyType = valueApprovaldata["PolicyType"].asString();
+		if(!valueApprovaldata["SchemaId"].isNull())
+			approvalObject.schemaId = valueApprovaldata["SchemaId"].asString();
+		if(!valueApprovaldata["SchemaName"].isNull())
+			approvalObject.schemaName = valueApprovaldata["SchemaName"].asString();
+		if(!valueApprovaldata["SchemaContent"].isNull())
+			approvalObject.schemaContent = valueApprovaldata["SchemaContent"].asString();
+		if(!valueApprovaldata["CreatorUserId"].isNull())
+			approvalObject.creatorUserId = valueApprovaldata["CreatorUserId"].asString();
+		if(!valueApprovaldata["CreatorDevTag"].isNull())
+			approvalObject.creatorDevTag = valueApprovaldata["CreatorDevTag"].asString();
+		if(!valueApprovaldata["CreateTime"].isNull())
+			approvalObject.createTime = valueApprovaldata["CreateTime"].asString();
+		if(!valueApprovaldata["Reason"].isNull())
+			approvalObject.reason = valueApprovaldata["Reason"].asString();
+		if(!valueApprovaldata["CreatorUsername"].isNull())
+			approvalObject.creatorUsername = valueApprovaldata["CreatorUsername"].asString();
+		if(!valueApprovaldata["CreatorDepartment"].isNull())
+			approvalObject.creatorDepartment = valueApprovaldata["CreatorDepartment"].asString();
+		auto allApprovalProgressesNode = valueApprovaldata["ApprovalProgresses"]["approvalProgressesItem"];
+		for (auto valueApprovaldataApprovalProgressesapprovalProgressesItem : allApprovalProgressesNode)
+		{
+			Data::ApprovalProgressesItem approvalProgressesObject;
+			if(!valueApprovaldataApprovalProgressesapprovalProgressesItem["Status"].isNull())
+				approvalProgressesObject.status = valueApprovaldataApprovalProgressesapprovalProgressesItem["Status"].asString();
+			if(!valueApprovaldataApprovalProgressesapprovalProgressesItem["Executor"].isNull())
+				approvalProgressesObject.executor = valueApprovaldataApprovalProgressesapprovalProgressesItem["Executor"].asString();
+			if(!valueApprovaldataApprovalProgressesapprovalProgressesItem["Action"].isNull())
+				approvalProgressesObject.action = valueApprovaldataApprovalProgressesapprovalProgressesItem["Action"].asString();
+			if(!valueApprovaldataApprovalProgressesapprovalProgressesItem["Comment"].isNull())
+				approvalProgressesObject.comment = valueApprovaldataApprovalProgressesapprovalProgressesItem["Comment"].asString();
+			if(!valueApprovaldataApprovalProgressesapprovalProgressesItem["Timestamp"].isNull())
+				approvalProgressesObject.timestamp = std::stol(valueApprovaldataApprovalProgressesapprovalProgressesItem["Timestamp"].asString());
+			auto allOperatorsNode = valueApprovaldataApprovalProgressesapprovalProgressesItem["Operators"]["operatorsItem"];
+			for (auto valueApprovaldataApprovalProgressesapprovalProgressesItemOperatorsoperatorsItem : allOperatorsNode)
+			{
+				Data::ApprovalProgressesItem::OperatorsItem operatorsObject;
+				if(!valueApprovaldataApprovalProgressesapprovalProgressesItemOperatorsoperatorsItem["SaseUserId"].isNull())
+					operatorsObject.saseUserId = valueApprovaldataApprovalProgressesapprovalProgressesItemOperatorsoperatorsItem["SaseUserId"].asString();
+				if(!valueApprovaldataApprovalProgressesapprovalProgressesItemOperatorsoperatorsItem["Username"].isNull())
+					operatorsObject.username = valueApprovaldataApprovalProgressesapprovalProgressesItemOperatorsoperatorsItem["Username"].asString();
+				approvalProgressesObject.operators.push_back(operatorsObject);
+			}
+			approvalObject.approvalProgresses.push_back(approvalProgressesObject);
+		}
+		approval_.push_back(approvalObject);
+	}
+
+}
+
+std::vector<GetApprovalResult::Data> GetApprovalResult::getApproval()const
+{
+	return approval_;
+}
+