Unified upgrade SDK.

VERSION

@@ -1 +1 @@
-1.36.2016
+1.36.2046

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

cloudauth/CMakeLists.txt

@@ -23,6 +23,8 @@ set(cloudauth_public_header
 set(cloudauth_public_header_model 
 	include/alibabacloud/cloudauth/model/AIGCFaceVerifyRequest.h
 	include/alibabacloud/cloudauth/model/AIGCFaceVerifyResult.h
+	include/alibabacloud/cloudauth/model/BankMetaVerifyRequest.h
+	include/alibabacloud/cloudauth/model/BankMetaVerifyResult.h
 	include/alibabacloud/cloudauth/model/CompareFaceVerifyRequest.h
 	include/alibabacloud/cloudauth/model/CompareFaceVerifyResult.h
 	include/alibabacloud/cloudauth/model/CompareFacesRequest.h
@@ -33,8 +35,16 @@ set(cloudauth_public_header_model
 	include/alibabacloud/cloudauth/model/CreateAuthKeyResult.h
 	include/alibabacloud/cloudauth/model/CreateVerifySettingRequest.h
 	include/alibabacloud/cloudauth/model/CreateVerifySettingResult.h
+	include/alibabacloud/cloudauth/model/CredentialVerifyRequest.h
+	include/alibabacloud/cloudauth/model/CredentialVerifyResult.h
+	include/alibabacloud/cloudauth/model/DeepfakeDetectRequest.h
+	include/alibabacloud/cloudauth/model/DeepfakeDetectResult.h
+	include/alibabacloud/cloudauth/model/DeleteFaceVerifyResultRequest.h
+	include/alibabacloud/cloudauth/model/DeleteFaceVerifyResultResult.h
 	include/alibabacloud/cloudauth/model/DescribeDeviceInfoRequest.h
 	include/alibabacloud/cloudauth/model/DescribeDeviceInfoResult.h
+	include/alibabacloud/cloudauth/model/DescribeFaceGuardRiskRequest.h
+	include/alibabacloud/cloudauth/model/DescribeFaceGuardRiskResult.h
 	include/alibabacloud/cloudauth/model/DescribeFaceVerifyRequest.h
 	include/alibabacloud/cloudauth/model/DescribeFaceVerifyResult.h
 	include/alibabacloud/cloudauth/model/DescribeOssUploadTokenRequest.h
@@ -51,18 +61,48 @@ set(cloudauth_public_header_model
 	include/alibabacloud/cloudauth/model/DescribeVerifyTokenResult.h
 	include/alibabacloud/cloudauth/model/DetectFaceAttributesRequest.h
 	include/alibabacloud/cloudauth/model/DetectFaceAttributesResult.h
+	include/alibabacloud/cloudauth/model/Id2MetaPeriodVerifyRequest.h
+	include/alibabacloud/cloudauth/model/Id2MetaPeriodVerifyResult.h
+	include/alibabacloud/cloudauth/model/Id2MetaStandardVerifyRequest.h
+	include/alibabacloud/cloudauth/model/Id2MetaStandardVerifyResult.h
 	include/alibabacloud/cloudauth/model/Id2MetaVerifyRequest.h
 	include/alibabacloud/cloudauth/model/Id2MetaVerifyResult.h
 	include/alibabacloud/cloudauth/model/InitFaceVerifyRequest.h
 	include/alibabacloud/cloudauth/model/InitFaceVerifyResult.h
+	include/alibabacloud/cloudauth/model/InsertWhiteListSettingRequest.h
+	include/alibabacloud/cloudauth/model/InsertWhiteListSettingResult.h
 	include/alibabacloud/cloudauth/model/LivenessFaceVerifyRequest.h
 	include/alibabacloud/cloudauth/model/LivenessFaceVerifyResult.h
+	include/alibabacloud/cloudauth/model/Mobile3MetaDetailStandardVerifyRequest.h
+	include/alibabacloud/cloudauth/model/Mobile3MetaDetailStandardVerifyResult.h
 	include/alibabacloud/cloudauth/model/Mobile3MetaDetailVerifyRequest.h
 	include/alibabacloud/cloudauth/model/Mobile3MetaDetailVerifyResult.h
+	include/alibabacloud/cloudauth/model/Mobile3MetaSimpleStandardVerifyRequest.h
+	include/alibabacloud/cloudauth/model/Mobile3MetaSimpleStandardVerifyResult.h
 	include/alibabacloud/cloudauth/model/Mobile3MetaSimpleVerifyRequest.h
 	include/alibabacloud/cloudauth/model/Mobile3MetaSimpleVerifyResult.h
+	include/alibabacloud/cloudauth/model/MobileDetectRequest.h
+	include/alibabacloud/cloudauth/model/MobileDetectResult.h
+	include/alibabacloud/cloudauth/model/MobileOnlineStatusRequest.h
+	include/alibabacloud/cloudauth/model/MobileOnlineStatusResult.h
+	include/alibabacloud/cloudauth/model/MobileOnlineTimeRequest.h
+	include/alibabacloud/cloudauth/model/MobileOnlineTimeResult.h
 	include/alibabacloud/cloudauth/model/ModifyDeviceInfoRequest.h
 	include/alibabacloud/cloudauth/model/ModifyDeviceInfoResult.h
+	include/alibabacloud/cloudauth/model/PageQueryWhiteListSettingRequest.h
+	include/alibabacloud/cloudauth/model/PageQueryWhiteListSettingResult.h
+	include/alibabacloud/cloudauth/model/RemoveWhiteListSettingRequest.h
+	include/alibabacloud/cloudauth/model/RemoveWhiteListSettingResult.h
+	include/alibabacloud/cloudauth/model/Vehicle5ItemQueryRequest.h
+	include/alibabacloud/cloudauth/model/Vehicle5ItemQueryResult.h
+	include/alibabacloud/cloudauth/model/VehicleInsureQueryRequest.h
+	include/alibabacloud/cloudauth/model/VehicleInsureQueryResult.h
+	include/alibabacloud/cloudauth/model/VehicleMetaVerifyRequest.h
+	include/alibabacloud/cloudauth/model/VehicleMetaVerifyResult.h
+	include/alibabacloud/cloudauth/model/VehicleMetaVerifyV2Request.h
+	include/alibabacloud/cloudauth/model/VehicleMetaVerifyV2Result.h
+	include/alibabacloud/cloudauth/model/VehicleQueryRequest.h
+	include/alibabacloud/cloudauth/model/VehicleQueryResult.h
 	include/alibabacloud/cloudauth/model/VerifyMaterialRequest.h
 	include/alibabacloud/cloudauth/model/VerifyMaterialResult.h )
 
@@ -70,6 +110,8 @@ set(cloudauth_src
 	src/CloudauthClient.cc
 	src/model/AIGCFaceVerifyRequest.cc
 	src/model/AIGCFaceVerifyResult.cc
+	src/model/BankMetaVerifyRequest.cc
+	src/model/BankMetaVerifyResult.cc
 	src/model/CompareFaceVerifyRequest.cc
 	src/model/CompareFaceVerifyResult.cc
 	src/model/CompareFacesRequest.cc
@@ -80,8 +122,16 @@ set(cloudauth_src
 	src/model/CreateAuthKeyResult.cc
 	src/model/CreateVerifySettingRequest.cc
 	src/model/CreateVerifySettingResult.cc
+	src/model/CredentialVerifyRequest.cc
+	src/model/CredentialVerifyResult.cc
+	src/model/DeepfakeDetectRequest.cc
+	src/model/DeepfakeDetectResult.cc
+	src/model/DeleteFaceVerifyResultRequest.cc
+	src/model/DeleteFaceVerifyResultResult.cc
 	src/model/DescribeDeviceInfoRequest.cc
 	src/model/DescribeDeviceInfoResult.cc
+	src/model/DescribeFaceGuardRiskRequest.cc
+	src/model/DescribeFaceGuardRiskResult.cc
 	src/model/DescribeFaceVerifyRequest.cc
 	src/model/DescribeFaceVerifyResult.cc
 	src/model/DescribeOssUploadTokenRequest.cc
@@ -98,18 +148,48 @@ set(cloudauth_src
 	src/model/DescribeVerifyTokenResult.cc
 	src/model/DetectFaceAttributesRequest.cc
 	src/model/DetectFaceAttributesResult.cc
+	src/model/Id2MetaPeriodVerifyRequest.cc
+	src/model/Id2MetaPeriodVerifyResult.cc
+	src/model/Id2MetaStandardVerifyRequest.cc
+	src/model/Id2MetaStandardVerifyResult.cc
 	src/model/Id2MetaVerifyRequest.cc
 	src/model/Id2MetaVerifyResult.cc
 	src/model/InitFaceVerifyRequest.cc
 	src/model/InitFaceVerifyResult.cc
+	src/model/InsertWhiteListSettingRequest.cc
+	src/model/InsertWhiteListSettingResult.cc
 	src/model/LivenessFaceVerifyRequest.cc
 	src/model/LivenessFaceVerifyResult.cc
+	src/model/Mobile3MetaDetailStandardVerifyRequest.cc
+	src/model/Mobile3MetaDetailStandardVerifyResult.cc
 	src/model/Mobile3MetaDetailVerifyRequest.cc
 	src/model/Mobile3MetaDetailVerifyResult.cc
+	src/model/Mobile3MetaSimpleStandardVerifyRequest.cc
+	src/model/Mobile3MetaSimpleStandardVerifyResult.cc
 	src/model/Mobile3MetaSimpleVerifyRequest.cc
 	src/model/Mobile3MetaSimpleVerifyResult.cc
+	src/model/MobileDetectRequest.cc
+	src/model/MobileDetectResult.cc
+	src/model/MobileOnlineStatusRequest.cc
+	src/model/MobileOnlineStatusResult.cc
+	src/model/MobileOnlineTimeRequest.cc
+	src/model/MobileOnlineTimeResult.cc
 	src/model/ModifyDeviceInfoRequest.cc
 	src/model/ModifyDeviceInfoResult.cc
+	src/model/PageQueryWhiteListSettingRequest.cc
+	src/model/PageQueryWhiteListSettingResult.cc
+	src/model/RemoveWhiteListSettingRequest.cc
+	src/model/RemoveWhiteListSettingResult.cc
+	src/model/Vehicle5ItemQueryRequest.cc
+	src/model/Vehicle5ItemQueryResult.cc
+	src/model/VehicleInsureQueryRequest.cc
+	src/model/VehicleInsureQueryResult.cc
+	src/model/VehicleMetaVerifyRequest.cc
+	src/model/VehicleMetaVerifyResult.cc
+	src/model/VehicleMetaVerifyV2Request.cc
+	src/model/VehicleMetaVerifyV2Result.cc
+	src/model/VehicleQueryRequest.cc
+	src/model/VehicleQueryResult.cc
 	src/model/VerifyMaterialRequest.cc
 	src/model/VerifyMaterialResult.cc )
 

cloudauth/include/alibabacloud/cloudauth/CloudauthClient.h

@@ -24,6 +24,8 @@
 #include "CloudauthExport.h"
 #include "model/AIGCFaceVerifyRequest.h"
 #include "model/AIGCFaceVerifyResult.h"
+#include "model/BankMetaVerifyRequest.h"
+#include "model/BankMetaVerifyResult.h"
 #include "model/CompareFaceVerifyRequest.h"
 #include "model/CompareFaceVerifyResult.h"
 #include "model/CompareFacesRequest.h"
@@ -34,8 +36,16 @@
 #include "model/CreateAuthKeyResult.h"
 #include "model/CreateVerifySettingRequest.h"
 #include "model/CreateVerifySettingResult.h"
+#include "model/CredentialVerifyRequest.h"
+#include "model/CredentialVerifyResult.h"
+#include "model/DeepfakeDetectRequest.h"
+#include "model/DeepfakeDetectResult.h"
+#include "model/DeleteFaceVerifyResultRequest.h"
+#include "model/DeleteFaceVerifyResultResult.h"
 #include "model/DescribeDeviceInfoRequest.h"
 #include "model/DescribeDeviceInfoResult.h"
+#include "model/DescribeFaceGuardRiskRequest.h"
+#include "model/DescribeFaceGuardRiskResult.h"
 #include "model/DescribeFaceVerifyRequest.h"
 #include "model/DescribeFaceVerifyResult.h"
 #include "model/DescribeOssUploadTokenRequest.h"
@@ -52,18 +62,48 @@
 #include "model/DescribeVerifyTokenResult.h"
 #include "model/DetectFaceAttributesRequest.h"
 #include "model/DetectFaceAttributesResult.h"
+#include "model/Id2MetaPeriodVerifyRequest.h"
+#include "model/Id2MetaPeriodVerifyResult.h"
+#include "model/Id2MetaStandardVerifyRequest.h"
+#include "model/Id2MetaStandardVerifyResult.h"
 #include "model/Id2MetaVerifyRequest.h"
 #include "model/Id2MetaVerifyResult.h"
 #include "model/InitFaceVerifyRequest.h"
 #include "model/InitFaceVerifyResult.h"
+#include "model/InsertWhiteListSettingRequest.h"
+#include "model/InsertWhiteListSettingResult.h"
 #include "model/LivenessFaceVerifyRequest.h"
 #include "model/LivenessFaceVerifyResult.h"
+#include "model/Mobile3MetaDetailStandardVerifyRequest.h"
+#include "model/Mobile3MetaDetailStandardVerifyResult.h"
 #include "model/Mobile3MetaDetailVerifyRequest.h"
 #include "model/Mobile3MetaDetailVerifyResult.h"
+#include "model/Mobile3MetaSimpleStandardVerifyRequest.h"
+#include "model/Mobile3MetaSimpleStandardVerifyResult.h"
 #include "model/Mobile3MetaSimpleVerifyRequest.h"
 #include "model/Mobile3MetaSimpleVerifyResult.h"
+#include "model/MobileDetectRequest.h"
+#include "model/MobileDetectResult.h"
+#include "model/MobileOnlineStatusRequest.h"
+#include "model/MobileOnlineStatusResult.h"
+#include "model/MobileOnlineTimeRequest.h"
+#include "model/MobileOnlineTimeResult.h"
 #include "model/ModifyDeviceInfoRequest.h"
 #include "model/ModifyDeviceInfoResult.h"
+#include "model/PageQueryWhiteListSettingRequest.h"
+#include "model/PageQueryWhiteListSettingResult.h"
+#include "model/RemoveWhiteListSettingRequest.h"
+#include "model/RemoveWhiteListSettingResult.h"
+#include "model/Vehicle5ItemQueryRequest.h"
+#include "model/Vehicle5ItemQueryResult.h"
+#include "model/VehicleInsureQueryRequest.h"
+#include "model/VehicleInsureQueryResult.h"
+#include "model/VehicleMetaVerifyRequest.h"
+#include "model/VehicleMetaVerifyResult.h"
+#include "model/VehicleMetaVerifyV2Request.h"
+#include "model/VehicleMetaVerifyV2Result.h"
+#include "model/VehicleQueryRequest.h"
+#include "model/VehicleQueryResult.h"
 #include "model/VerifyMaterialRequest.h"
 #include "model/VerifyMaterialResult.h"
 
@@ -78,6 +118,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AIGCFaceVerifyResult> AIGCFaceVerifyOutcome;
 			typedef std::future<AIGCFaceVerifyOutcome> AIGCFaceVerifyOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::AIGCFaceVerifyRequest&, const AIGCFaceVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AIGCFaceVerifyAsyncHandler;
+			typedef Outcome<Error, Model::BankMetaVerifyResult> BankMetaVerifyOutcome;
+			typedef std::future<BankMetaVerifyOutcome> BankMetaVerifyOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::BankMetaVerifyRequest&, const BankMetaVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BankMetaVerifyAsyncHandler;
 			typedef Outcome<Error, Model::CompareFaceVerifyResult> CompareFaceVerifyOutcome;
 			typedef std::future<CompareFaceVerifyOutcome> CompareFaceVerifyOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::CompareFaceVerifyRequest&, const CompareFaceVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompareFaceVerifyAsyncHandler;
@@ -93,9 +136,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateVerifySettingResult> CreateVerifySettingOutcome;
 			typedef std::future<CreateVerifySettingOutcome> CreateVerifySettingOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::CreateVerifySettingRequest&, const CreateVerifySettingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateVerifySettingAsyncHandler;
+			typedef Outcome<Error, Model::CredentialVerifyResult> CredentialVerifyOutcome;
+			typedef std::future<CredentialVerifyOutcome> CredentialVerifyOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::CredentialVerifyRequest&, const CredentialVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CredentialVerifyAsyncHandler;
+			typedef Outcome<Error, Model::DeepfakeDetectResult> DeepfakeDetectOutcome;
+			typedef std::future<DeepfakeDetectOutcome> DeepfakeDetectOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::DeepfakeDetectRequest&, const DeepfakeDetectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeepfakeDetectAsyncHandler;
+			typedef Outcome<Error, Model::DeleteFaceVerifyResultResult> DeleteFaceVerifyResultOutcome;
+			typedef std::future<DeleteFaceVerifyResultOutcome> DeleteFaceVerifyResultOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::DeleteFaceVerifyResultRequest&, const DeleteFaceVerifyResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteFaceVerifyResultAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDeviceInfoResult> DescribeDeviceInfoOutcome;
 			typedef std::future<DescribeDeviceInfoOutcome> DescribeDeviceInfoOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::DescribeDeviceInfoRequest&, const DescribeDeviceInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDeviceInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeFaceGuardRiskResult> DescribeFaceGuardRiskOutcome;
+			typedef std::future<DescribeFaceGuardRiskOutcome> DescribeFaceGuardRiskOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::DescribeFaceGuardRiskRequest&, const DescribeFaceGuardRiskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFaceGuardRiskAsyncHandler;
 			typedef Outcome<Error, Model::DescribeFaceVerifyResult> DescribeFaceVerifyOutcome;
 			typedef std::future<DescribeFaceVerifyOutcome> DescribeFaceVerifyOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::DescribeFaceVerifyRequest&, const DescribeFaceVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFaceVerifyAsyncHandler;
@@ -120,24 +175,69 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DetectFaceAttributesResult> DetectFaceAttributesOutcome;
 			typedef std::future<DetectFaceAttributesOutcome> DetectFaceAttributesOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::DetectFaceAttributesRequest&, const DetectFaceAttributesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectFaceAttributesAsyncHandler;
+			typedef Outcome<Error, Model::Id2MetaPeriodVerifyResult> Id2MetaPeriodVerifyOutcome;
+			typedef std::future<Id2MetaPeriodVerifyOutcome> Id2MetaPeriodVerifyOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::Id2MetaPeriodVerifyRequest&, const Id2MetaPeriodVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> Id2MetaPeriodVerifyAsyncHandler;
+			typedef Outcome<Error, Model::Id2MetaStandardVerifyResult> Id2MetaStandardVerifyOutcome;
+			typedef std::future<Id2MetaStandardVerifyOutcome> Id2MetaStandardVerifyOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::Id2MetaStandardVerifyRequest&, const Id2MetaStandardVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> Id2MetaStandardVerifyAsyncHandler;
 			typedef Outcome<Error, Model::Id2MetaVerifyResult> Id2MetaVerifyOutcome;
 			typedef std::future<Id2MetaVerifyOutcome> Id2MetaVerifyOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::Id2MetaVerifyRequest&, const Id2MetaVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> Id2MetaVerifyAsyncHandler;
 			typedef Outcome<Error, Model::InitFaceVerifyResult> InitFaceVerifyOutcome;
 			typedef std::future<InitFaceVerifyOutcome> InitFaceVerifyOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::InitFaceVerifyRequest&, const InitFaceVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InitFaceVerifyAsyncHandler;
+			typedef Outcome<Error, Model::InsertWhiteListSettingResult> InsertWhiteListSettingOutcome;
+			typedef std::future<InsertWhiteListSettingOutcome> InsertWhiteListSettingOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::InsertWhiteListSettingRequest&, const InsertWhiteListSettingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InsertWhiteListSettingAsyncHandler;
 			typedef Outcome<Error, Model::LivenessFaceVerifyResult> LivenessFaceVerifyOutcome;
 			typedef std::future<LivenessFaceVerifyOutcome> LivenessFaceVerifyOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::LivenessFaceVerifyRequest&, const LivenessFaceVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LivenessFaceVerifyAsyncHandler;
+			typedef Outcome<Error, Model::Mobile3MetaDetailStandardVerifyResult> Mobile3MetaDetailStandardVerifyOutcome;
+			typedef std::future<Mobile3MetaDetailStandardVerifyOutcome> Mobile3MetaDetailStandardVerifyOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::Mobile3MetaDetailStandardVerifyRequest&, const Mobile3MetaDetailStandardVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> Mobile3MetaDetailStandardVerifyAsyncHandler;
 			typedef Outcome<Error, Model::Mobile3MetaDetailVerifyResult> Mobile3MetaDetailVerifyOutcome;
 			typedef std::future<Mobile3MetaDetailVerifyOutcome> Mobile3MetaDetailVerifyOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::Mobile3MetaDetailVerifyRequest&, const Mobile3MetaDetailVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> Mobile3MetaDetailVerifyAsyncHandler;
+			typedef Outcome<Error, Model::Mobile3MetaSimpleStandardVerifyResult> Mobile3MetaSimpleStandardVerifyOutcome;
+			typedef std::future<Mobile3MetaSimpleStandardVerifyOutcome> Mobile3MetaSimpleStandardVerifyOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::Mobile3MetaSimpleStandardVerifyRequest&, const Mobile3MetaSimpleStandardVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> Mobile3MetaSimpleStandardVerifyAsyncHandler;
 			typedef Outcome<Error, Model::Mobile3MetaSimpleVerifyResult> Mobile3MetaSimpleVerifyOutcome;
 			typedef std::future<Mobile3MetaSimpleVerifyOutcome> Mobile3MetaSimpleVerifyOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::Mobile3MetaSimpleVerifyRequest&, const Mobile3MetaSimpleVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> Mobile3MetaSimpleVerifyAsyncHandler;
+			typedef Outcome<Error, Model::MobileDetectResult> MobileDetectOutcome;
+			typedef std::future<MobileDetectOutcome> MobileDetectOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::MobileDetectRequest&, const MobileDetectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MobileDetectAsyncHandler;
+			typedef Outcome<Error, Model::MobileOnlineStatusResult> MobileOnlineStatusOutcome;
+			typedef std::future<MobileOnlineStatusOutcome> MobileOnlineStatusOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::MobileOnlineStatusRequest&, const MobileOnlineStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MobileOnlineStatusAsyncHandler;
+			typedef Outcome<Error, Model::MobileOnlineTimeResult> MobileOnlineTimeOutcome;
+			typedef std::future<MobileOnlineTimeOutcome> MobileOnlineTimeOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::MobileOnlineTimeRequest&, const MobileOnlineTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MobileOnlineTimeAsyncHandler;
 			typedef Outcome<Error, Model::ModifyDeviceInfoResult> ModifyDeviceInfoOutcome;
 			typedef std::future<ModifyDeviceInfoOutcome> ModifyDeviceInfoOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::ModifyDeviceInfoRequest&, const ModifyDeviceInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDeviceInfoAsyncHandler;
+			typedef Outcome<Error, Model::PageQueryWhiteListSettingResult> PageQueryWhiteListSettingOutcome;
+			typedef std::future<PageQueryWhiteListSettingOutcome> PageQueryWhiteListSettingOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::PageQueryWhiteListSettingRequest&, const PageQueryWhiteListSettingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PageQueryWhiteListSettingAsyncHandler;
+			typedef Outcome<Error, Model::RemoveWhiteListSettingResult> RemoveWhiteListSettingOutcome;
+			typedef std::future<RemoveWhiteListSettingOutcome> RemoveWhiteListSettingOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::RemoveWhiteListSettingRequest&, const RemoveWhiteListSettingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveWhiteListSettingAsyncHandler;
+			typedef Outcome<Error, Model::Vehicle5ItemQueryResult> Vehicle5ItemQueryOutcome;
+			typedef std::future<Vehicle5ItemQueryOutcome> Vehicle5ItemQueryOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::Vehicle5ItemQueryRequest&, const Vehicle5ItemQueryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> Vehicle5ItemQueryAsyncHandler;
+			typedef Outcome<Error, Model::VehicleInsureQueryResult> VehicleInsureQueryOutcome;
+			typedef std::future<VehicleInsureQueryOutcome> VehicleInsureQueryOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::VehicleInsureQueryRequest&, const VehicleInsureQueryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VehicleInsureQueryAsyncHandler;
+			typedef Outcome<Error, Model::VehicleMetaVerifyResult> VehicleMetaVerifyOutcome;
+			typedef std::future<VehicleMetaVerifyOutcome> VehicleMetaVerifyOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::VehicleMetaVerifyRequest&, const VehicleMetaVerifyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VehicleMetaVerifyAsyncHandler;
+			typedef Outcome<Error, Model::VehicleMetaVerifyV2Result> VehicleMetaVerifyV2Outcome;
+			typedef std::future<VehicleMetaVerifyV2Outcome> VehicleMetaVerifyV2OutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::VehicleMetaVerifyV2Request&, const VehicleMetaVerifyV2Outcome&, const std::shared_ptr<const AsyncCallerContext>&)> VehicleMetaVerifyV2AsyncHandler;
+			typedef Outcome<Error, Model::VehicleQueryResult> VehicleQueryOutcome;
+			typedef std::future<VehicleQueryOutcome> VehicleQueryOutcomeCallable;
+			typedef std::function<void(const CloudauthClient*, const Model::VehicleQueryRequest&, const VehicleQueryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VehicleQueryAsyncHandler;
 			typedef Outcome<Error, Model::VerifyMaterialResult> VerifyMaterialOutcome;
 			typedef std::future<VerifyMaterialOutcome> VerifyMaterialOutcomeCallable;
 			typedef std::function<void(const CloudauthClient*, const Model::VerifyMaterialRequest&, const VerifyMaterialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyMaterialAsyncHandler;
@@ -149,6 +249,9 @@ namespace AlibabaCloud
 			AIGCFaceVerifyOutcome aIGCFaceVerify(const Model::AIGCFaceVerifyRequest &request)const;
 			void aIGCFaceVerifyAsync(const Model::AIGCFaceVerifyRequest& request, const AIGCFaceVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AIGCFaceVerifyOutcomeCallable aIGCFaceVerifyCallable(const Model::AIGCFaceVerifyRequest& request) const;
+			BankMetaVerifyOutcome bankMetaVerify(const Model::BankMetaVerifyRequest &request)const;
+			void bankMetaVerifyAsync(const Model::BankMetaVerifyRequest& request, const BankMetaVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			BankMetaVerifyOutcomeCallable bankMetaVerifyCallable(const Model::BankMetaVerifyRequest& request) const;
 			CompareFaceVerifyOutcome compareFaceVerify(const Model::CompareFaceVerifyRequest &request)const;
 			void compareFaceVerifyAsync(const Model::CompareFaceVerifyRequest& request, const CompareFaceVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CompareFaceVerifyOutcomeCallable compareFaceVerifyCallable(const Model::CompareFaceVerifyRequest& request) const;
@@ -164,9 +267,21 @@ namespace AlibabaCloud
 			CreateVerifySettingOutcome createVerifySetting(const Model::CreateVerifySettingRequest &request)const;
 			void createVerifySettingAsync(const Model::CreateVerifySettingRequest& request, const CreateVerifySettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateVerifySettingOutcomeCallable createVerifySettingCallable(const Model::CreateVerifySettingRequest& request) const;
+			CredentialVerifyOutcome credentialVerify(const Model::CredentialVerifyRequest &request)const;
+			void credentialVerifyAsync(const Model::CredentialVerifyRequest& request, const CredentialVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CredentialVerifyOutcomeCallable credentialVerifyCallable(const Model::CredentialVerifyRequest& request) const;
+			DeepfakeDetectOutcome deepfakeDetect(const Model::DeepfakeDetectRequest &request)const;
+			void deepfakeDetectAsync(const Model::DeepfakeDetectRequest& request, const DeepfakeDetectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeepfakeDetectOutcomeCallable deepfakeDetectCallable(const Model::DeepfakeDetectRequest& request) const;
+			DeleteFaceVerifyResultOutcome deleteFaceVerifyResult(const Model::DeleteFaceVerifyResultRequest &request)const;
+			void deleteFaceVerifyResultAsync(const Model::DeleteFaceVerifyResultRequest& request, const DeleteFaceVerifyResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteFaceVerifyResultOutcomeCallable deleteFaceVerifyResultCallable(const Model::DeleteFaceVerifyResultRequest& request) const;
 			DescribeDeviceInfoOutcome describeDeviceInfo(const Model::DescribeDeviceInfoRequest &request)const;
 			void describeDeviceInfoAsync(const Model::DescribeDeviceInfoRequest& request, const DescribeDeviceInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDeviceInfoOutcomeCallable describeDeviceInfoCallable(const Model::DescribeDeviceInfoRequest& request) const;
+			DescribeFaceGuardRiskOutcome describeFaceGuardRisk(const Model::DescribeFaceGuardRiskRequest &request)const;
+			void describeFaceGuardRiskAsync(const Model::DescribeFaceGuardRiskRequest& request, const DescribeFaceGuardRiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeFaceGuardRiskOutcomeCallable describeFaceGuardRiskCallable(const Model::DescribeFaceGuardRiskRequest& request) const;
 			DescribeFaceVerifyOutcome describeFaceVerify(const Model::DescribeFaceVerifyRequest &request)const;
 			void describeFaceVerifyAsync(const Model::DescribeFaceVerifyRequest& request, const DescribeFaceVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeFaceVerifyOutcomeCallable describeFaceVerifyCallable(const Model::DescribeFaceVerifyRequest& request) const;
@@ -191,24 +306,69 @@ namespace AlibabaCloud
 			DetectFaceAttributesOutcome detectFaceAttributes(const Model::DetectFaceAttributesRequest &request)const;
 			void detectFaceAttributesAsync(const Model::DetectFaceAttributesRequest& request, const DetectFaceAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectFaceAttributesOutcomeCallable detectFaceAttributesCallable(const Model::DetectFaceAttributesRequest& request) const;
+			Id2MetaPeriodVerifyOutcome id2MetaPeriodVerify(const Model::Id2MetaPeriodVerifyRequest &request)const;
+			void id2MetaPeriodVerifyAsync(const Model::Id2MetaPeriodVerifyRequest& request, const Id2MetaPeriodVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			Id2MetaPeriodVerifyOutcomeCallable id2MetaPeriodVerifyCallable(const Model::Id2MetaPeriodVerifyRequest& request) const;
+			Id2MetaStandardVerifyOutcome id2MetaStandardVerify(const Model::Id2MetaStandardVerifyRequest &request)const;
+			void id2MetaStandardVerifyAsync(const Model::Id2MetaStandardVerifyRequest& request, const Id2MetaStandardVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			Id2MetaStandardVerifyOutcomeCallable id2MetaStandardVerifyCallable(const Model::Id2MetaStandardVerifyRequest& request) const;
 			Id2MetaVerifyOutcome id2MetaVerify(const Model::Id2MetaVerifyRequest &request)const;
 			void id2MetaVerifyAsync(const Model::Id2MetaVerifyRequest& request, const Id2MetaVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			Id2MetaVerifyOutcomeCallable id2MetaVerifyCallable(const Model::Id2MetaVerifyRequest& request) const;
 			InitFaceVerifyOutcome initFaceVerify(const Model::InitFaceVerifyRequest &request)const;
 			void initFaceVerifyAsync(const Model::InitFaceVerifyRequest& request, const InitFaceVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			InitFaceVerifyOutcomeCallable initFaceVerifyCallable(const Model::InitFaceVerifyRequest& request) const;
+			InsertWhiteListSettingOutcome insertWhiteListSetting(const Model::InsertWhiteListSettingRequest &request)const;
+			void insertWhiteListSettingAsync(const Model::InsertWhiteListSettingRequest& request, const InsertWhiteListSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			InsertWhiteListSettingOutcomeCallable insertWhiteListSettingCallable(const Model::InsertWhiteListSettingRequest& request) const;
 			LivenessFaceVerifyOutcome livenessFaceVerify(const Model::LivenessFaceVerifyRequest &request)const;
 			void livenessFaceVerifyAsync(const Model::LivenessFaceVerifyRequest& request, const LivenessFaceVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			LivenessFaceVerifyOutcomeCallable livenessFaceVerifyCallable(const Model::LivenessFaceVerifyRequest& request) const;
+			Mobile3MetaDetailStandardVerifyOutcome mobile3MetaDetailStandardVerify(const Model::Mobile3MetaDetailStandardVerifyRequest &request)const;
+			void mobile3MetaDetailStandardVerifyAsync(const Model::Mobile3MetaDetailStandardVerifyRequest& request, const Mobile3MetaDetailStandardVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			Mobile3MetaDetailStandardVerifyOutcomeCallable mobile3MetaDetailStandardVerifyCallable(const Model::Mobile3MetaDetailStandardVerifyRequest& request) const;
 			Mobile3MetaDetailVerifyOutcome mobile3MetaDetailVerify(const Model::Mobile3MetaDetailVerifyRequest &request)const;
 			void mobile3MetaDetailVerifyAsync(const Model::Mobile3MetaDetailVerifyRequest& request, const Mobile3MetaDetailVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			Mobile3MetaDetailVerifyOutcomeCallable mobile3MetaDetailVerifyCallable(const Model::Mobile3MetaDetailVerifyRequest& request) const;
+			Mobile3MetaSimpleStandardVerifyOutcome mobile3MetaSimpleStandardVerify(const Model::Mobile3MetaSimpleStandardVerifyRequest &request)const;
+			void mobile3MetaSimpleStandardVerifyAsync(const Model::Mobile3MetaSimpleStandardVerifyRequest& request, const Mobile3MetaSimpleStandardVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			Mobile3MetaSimpleStandardVerifyOutcomeCallable mobile3MetaSimpleStandardVerifyCallable(const Model::Mobile3MetaSimpleStandardVerifyRequest& request) const;
 			Mobile3MetaSimpleVerifyOutcome mobile3MetaSimpleVerify(const Model::Mobile3MetaSimpleVerifyRequest &request)const;
 			void mobile3MetaSimpleVerifyAsync(const Model::Mobile3MetaSimpleVerifyRequest& request, const Mobile3MetaSimpleVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			Mobile3MetaSimpleVerifyOutcomeCallable mobile3MetaSimpleVerifyCallable(const Model::Mobile3MetaSimpleVerifyRequest& request) const;
+			MobileDetectOutcome mobileDetect(const Model::MobileDetectRequest &request)const;
+			void mobileDetectAsync(const Model::MobileDetectRequest& request, const MobileDetectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			MobileDetectOutcomeCallable mobileDetectCallable(const Model::MobileDetectRequest& request) const;
+			MobileOnlineStatusOutcome mobileOnlineStatus(const Model::MobileOnlineStatusRequest &request)const;
+			void mobileOnlineStatusAsync(const Model::MobileOnlineStatusRequest& request, const MobileOnlineStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			MobileOnlineStatusOutcomeCallable mobileOnlineStatusCallable(const Model::MobileOnlineStatusRequest& request) const;
+			MobileOnlineTimeOutcome mobileOnlineTime(const Model::MobileOnlineTimeRequest &request)const;
+			void mobileOnlineTimeAsync(const Model::MobileOnlineTimeRequest& request, const MobileOnlineTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			MobileOnlineTimeOutcomeCallable mobileOnlineTimeCallable(const Model::MobileOnlineTimeRequest& request) const;
 			ModifyDeviceInfoOutcome modifyDeviceInfo(const Model::ModifyDeviceInfoRequest &request)const;
 			void modifyDeviceInfoAsync(const Model::ModifyDeviceInfoRequest& request, const ModifyDeviceInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyDeviceInfoOutcomeCallable modifyDeviceInfoCallable(const Model::ModifyDeviceInfoRequest& request) const;
+			PageQueryWhiteListSettingOutcome pageQueryWhiteListSetting(const Model::PageQueryWhiteListSettingRequest &request)const;
+			void pageQueryWhiteListSettingAsync(const Model::PageQueryWhiteListSettingRequest& request, const PageQueryWhiteListSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PageQueryWhiteListSettingOutcomeCallable pageQueryWhiteListSettingCallable(const Model::PageQueryWhiteListSettingRequest& request) const;
+			RemoveWhiteListSettingOutcome removeWhiteListSetting(const Model::RemoveWhiteListSettingRequest &request)const;
+			void removeWhiteListSettingAsync(const Model::RemoveWhiteListSettingRequest& request, const RemoveWhiteListSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveWhiteListSettingOutcomeCallable removeWhiteListSettingCallable(const Model::RemoveWhiteListSettingRequest& request) const;
+			Vehicle5ItemQueryOutcome vehicle5ItemQuery(const Model::Vehicle5ItemQueryRequest &request)const;
+			void vehicle5ItemQueryAsync(const Model::Vehicle5ItemQueryRequest& request, const Vehicle5ItemQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			Vehicle5ItemQueryOutcomeCallable vehicle5ItemQueryCallable(const Model::Vehicle5ItemQueryRequest& request) const;
+			VehicleInsureQueryOutcome vehicleInsureQuery(const Model::VehicleInsureQueryRequest &request)const;
+			void vehicleInsureQueryAsync(const Model::VehicleInsureQueryRequest& request, const VehicleInsureQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VehicleInsureQueryOutcomeCallable vehicleInsureQueryCallable(const Model::VehicleInsureQueryRequest& request) const;
+			VehicleMetaVerifyOutcome vehicleMetaVerify(const Model::VehicleMetaVerifyRequest &request)const;
+			void vehicleMetaVerifyAsync(const Model::VehicleMetaVerifyRequest& request, const VehicleMetaVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VehicleMetaVerifyOutcomeCallable vehicleMetaVerifyCallable(const Model::VehicleMetaVerifyRequest& request) const;
+			VehicleMetaVerifyV2Outcome vehicleMetaVerifyV2(const Model::VehicleMetaVerifyV2Request &request)const;
+			void vehicleMetaVerifyV2Async(const Model::VehicleMetaVerifyV2Request& request, const VehicleMetaVerifyV2AsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VehicleMetaVerifyV2OutcomeCallable vehicleMetaVerifyV2Callable(const Model::VehicleMetaVerifyV2Request& request) const;
+			VehicleQueryOutcome vehicleQuery(const Model::VehicleQueryRequest &request)const;
+			void vehicleQueryAsync(const Model::VehicleQueryRequest& request, const VehicleQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VehicleQueryOutcomeCallable vehicleQueryCallable(const Model::VehicleQueryRequest& request) const;
 			VerifyMaterialOutcome verifyMaterial(const Model::VerifyMaterialRequest &request)const;
 			void verifyMaterialAsync(const Model::VerifyMaterialRequest& request, const VerifyMaterialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			VerifyMaterialOutcomeCallable verifyMaterialCallable(const Model::VerifyMaterialRequest& request) const;

cloudauth/include/alibabacloud/cloudauth/model/BankMetaVerifyRequest.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_CLOUDAUTH_MODEL_BANKMETAVERIFYREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_BANKMETAVERIFYREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT BankMetaVerifyRequest : public RpcServiceRequest {
+public:
+	BankMetaVerifyRequest();
+	~BankMetaVerifyRequest();
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getVerifyMode() const;
+	void setVerifyMode(const std::string &verifyMode);
+	std::string getIdentityType() const;
+	void setIdentityType(const std::string &identityType);
+	std::string getMobile() const;
+	void setMobile(const std::string &mobile);
+	std::string getIdentifyNum() const;
+	void setIdentifyNum(const std::string &identifyNum);
+	std::string getProductType() const;
+	void setProductType(const std::string &productType);
+	std::string getBankCard() const;
+	void setBankCard(const std::string &bankCard);
+	std::string getUserName() const;
+	void setUserName(const std::string &userName);
+
+private:
+	std::string paramType_;
+	std::string verifyMode_;
+	std::string identityType_;
+	std::string mobile_;
+	std::string identifyNum_;
+	std::string productType_;
+	std::string bankCard_;
+	std::string userName_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_BANKMETAVERIFYREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/BankMetaVerifyResult.h

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

cloudauth/include/alibabacloud/cloudauth/model/CredentialVerifyRequest.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_CLOUDAUTH_MODEL_CREDENTIALVERIFYREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_CREDENTIALVERIFYREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT CredentialVerifyRequest : public RpcServiceRequest {
+public:
+	struct MerchantDetail {
+		std::string value;
+		std::string key;
+	};
+	CredentialVerifyRequest();
+	~CredentialVerifyRequest();
+	std::string getProductCode() const;
+	void setProductCode(const std::string &productCode);
+	std::string getIsOCR() const;
+	void setIsOCR(const std::string &isOCR);
+	std::string getIsCheck() const;
+	void setIsCheck(const std::string &isCheck);
+	std::string getImageContext() const;
+	void setImageContext(const std::string &imageContext);
+	std::string getCredType() const;
+	void setCredType(const std::string &credType);
+	std::string getPromptModel() const;
+	void setPromptModel(const std::string &promptModel);
+	std::string getIdentifyNum() const;
+	void setIdentifyNum(const std::string &identifyNum);
+	std::string getCredName() const;
+	void setCredName(const std::string &credName);
+	std::string getMerchantId() const;
+	void setMerchantId(const std::string &merchantId);
+	std::vector<MerchantDetail> getMerchantDetail() const;
+	void setMerchantDetail(const std::vector<MerchantDetail> &merchantDetail);
+	std::string getImageUrl() const;
+	void setImageUrl(const std::string &imageUrl);
+	std::string getCertNum() const;
+	void setCertNum(const std::string &certNum);
+	std::string getPrompt() const;
+	void setPrompt(const std::string &prompt);
+	std::string getUserName() const;
+	void setUserName(const std::string &userName);
+
+private:
+	std::string productCode_;
+	std::string isOCR_;
+	std::string isCheck_;
+	std::string imageContext_;
+	std::string credType_;
+	std::string promptModel_;
+	std::string identifyNum_;
+	std::string credName_;
+	std::string merchantId_;
+	std::vector<MerchantDetail> merchantDetail_;
+	std::string imageUrl_;
+	std::string certNum_;
+	std::string prompt_;
+	std::string userName_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_CREDENTIALVERIFYREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/CredentialVerifyResult.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_CLOUDAUTH_MODEL_CREDENTIALVERIFYRESULT_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_CREDENTIALVERIFYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cloudauth
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLOUDAUTH_EXPORT CredentialVerifyResult : public ServiceResult
+			{
+			public:
+				struct ResultObject
+				{
+					struct VlResult
+					{
+						bool success;
+						std::string vlContent;
+					};
+					std::string riskTag;
+					std::string riskScore;
+					std::string ocrInfo;
+					std::string materialInfo;
+					VlResult vlResult;
+					std::string verifyResult;
+					std::string verifyDetail;
+					std::string result;
+				};
+
+
+				CredentialVerifyResult();
+				explicit CredentialVerifyResult(const std::string &payload);
+				~CredentialVerifyResult();
+				ResultObject getResultObject()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ResultObject resultObject_;
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_CREDENTIALVERIFYRESULT_H_

cloudauth/include/alibabacloud/cloudauth/model/DeepfakeDetectRequest.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_CLOUDAUTH_MODEL_DEEPFAKEDETECTREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_DEEPFAKEDETECTREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT DeepfakeDetectRequest : public RpcServiceRequest {
+public:
+	DeepfakeDetectRequest();
+	~DeepfakeDetectRequest();
+	std::string getFaceBase64() const;
+	void setFaceBase64(const std::string &faceBase64);
+	std::string getOuterOrderNo() const;
+	void setOuterOrderNo(const std::string &outerOrderNo);
+	std::string getFaceUrl() const;
+	void setFaceUrl(const std::string &faceUrl);
+	std::string getFaceInputType() const;
+	void setFaceInputType(const std::string &faceInputType);
+
+private:
+	std::string faceBase64_;
+	std::string outerOrderNo_;
+	std::string faceUrl_;
+	std::string faceInputType_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_DEEPFAKEDETECTREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/DeepfakeDetectResult.h

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

cloudauth/include/alibabacloud/cloudauth/model/DeleteFaceVerifyResultRequest.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_CLOUDAUTH_MODEL_DELETEFACEVERIFYRESULTREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_DELETEFACEVERIFYRESULTREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT DeleteFaceVerifyResultRequest : public RpcServiceRequest {
+public:
+	DeleteFaceVerifyResultRequest();
+	~DeleteFaceVerifyResultRequest();
+	std::string getDeleteAfterQuery() const;
+	void setDeleteAfterQuery(const std::string &deleteAfterQuery);
+	std::string getCertifyId() const;
+	void setCertifyId(const std::string &certifyId);
+
+private:
+	std::string deleteAfterQuery_;
+	std::string certifyId_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_DELETEFACEVERIFYRESULTREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/DeleteFaceVerifyResultResult.h

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

cloudauth/include/alibabacloud/cloudauth/model/DescribeFaceGuardRiskRequest.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_CLOUDAUTH_MODEL_DESCRIBEFACEGUARDRISKREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_DESCRIBEFACEGUARDRISKREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT DescribeFaceGuardRiskRequest : public RpcServiceRequest {
+public:
+	DescribeFaceGuardRiskRequest();
+	~DescribeFaceGuardRiskRequest();
+	std::string getProductCode() const;
+	void setProductCode(const std::string &productCode);
+	std::string getDeviceToken() const;
+	void setDeviceToken(const std::string &deviceToken);
+	std::string getOuterOrderNo() const;
+	void setOuterOrderNo(const std::string &outerOrderNo);
+	std::string getBizId() const;
+	void setBizId(const std::string &bizId);
+
+private:
+	std::string productCode_;
+	std::string deviceToken_;
+	std::string outerOrderNo_;
+	std::string bizId_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_DESCRIBEFACEGUARDRISKREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/DescribeFaceGuardRiskResult.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_CLOUDAUTH_MODEL_DESCRIBEFACEGUARDRISKRESULT_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_DESCRIBEFACEGUARDRISKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cloudauth
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLOUDAUTH_EXPORT DescribeFaceGuardRiskResult : public ServiceResult
+			{
+			public:
+				struct ResultObject
+				{
+					std::string certifyId;
+					std::string riskExtends;
+					std::string riakTags;
+					std::string riskTags;
+				};
+
+
+				DescribeFaceGuardRiskResult();
+				explicit DescribeFaceGuardRiskResult(const std::string &payload);
+				~DescribeFaceGuardRiskResult();
+				ResultObject getResultObject()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ResultObject resultObject_;
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_DESCRIBEFACEGUARDRISKRESULT_H_

cloudauth/include/alibabacloud/cloudauth/model/Id2MetaPeriodVerifyRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CLOUDAUTH_MODEL_ID2METAPERIODVERIFYREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_ID2METAPERIODVERIFYREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT Id2MetaPeriodVerifyRequest : public RpcServiceRequest {
+public:
+	Id2MetaPeriodVerifyRequest();
+	~Id2MetaPeriodVerifyRequest();
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getValidityStartDate() const;
+	void setValidityStartDate(const std::string &validityStartDate);
+	std::string getValidityEndDate() const;
+	void setValidityEndDate(const std::string &validityEndDate);
+	std::string getIdentifyNum() const;
+	void setIdentifyNum(const std::string &identifyNum);
+	std::string getUserName() const;
+	void setUserName(const std::string &userName);
+
+private:
+	std::string paramType_;
+	std::string validityStartDate_;
+	std::string validityEndDate_;
+	std::string identifyNum_;
+	std::string userName_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_ID2METAPERIODVERIFYREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/Id2MetaPeriodVerifyResult.h

@@ -0,0 +1,59 @@
+/*
+ * 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_CLOUDAUTH_MODEL_ID2METAPERIODVERIFYRESULT_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_ID2METAPERIODVERIFYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cloudauth
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLOUDAUTH_EXPORT Id2MetaPeriodVerifyResult : public ServiceResult
+			{
+			public:
+				struct ResultObject
+				{
+					std::string bizCode;
+				};
+
+
+				Id2MetaPeriodVerifyResult();
+				explicit Id2MetaPeriodVerifyResult(const std::string &payload);
+				~Id2MetaPeriodVerifyResult();
+				ResultObject getResultObject()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ResultObject resultObject_;
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_ID2METAPERIODVERIFYRESULT_H_

cloudauth/include/alibabacloud/cloudauth/model/Id2MetaStandardVerifyRequest.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_CLOUDAUTH_MODEL_ID2METASTANDARDVERIFYREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_ID2METASTANDARDVERIFYREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT Id2MetaStandardVerifyRequest : public RpcServiceRequest {
+public:
+	Id2MetaStandardVerifyRequest();
+	~Id2MetaStandardVerifyRequest();
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getIdentifyNum() const;
+	void setIdentifyNum(const std::string &identifyNum);
+	std::string getUserName() const;
+	void setUserName(const std::string &userName);
+
+private:
+	std::string paramType_;
+	std::string identifyNum_;
+	std::string userName_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_ID2METASTANDARDVERIFYREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/Id2MetaStandardVerifyResult.h

@@ -0,0 +1,59 @@
+/*
+ * 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_CLOUDAUTH_MODEL_ID2METASTANDARDVERIFYRESULT_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_ID2METASTANDARDVERIFYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cloudauth
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLOUDAUTH_EXPORT Id2MetaStandardVerifyResult : public ServiceResult
+			{
+			public:
+				struct ResultObject
+				{
+					std::string bizCode;
+				};
+
+
+				Id2MetaStandardVerifyResult();
+				explicit Id2MetaStandardVerifyResult(const std::string &payload);
+				~Id2MetaStandardVerifyResult();
+				ResultObject getResultObject()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ResultObject resultObject_;
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_ID2METASTANDARDVERIFYRESULT_H_

cloudauth/include/alibabacloud/cloudauth/model/InitFaceVerifyRequest.h

@@ -30,10 +30,6 @@ class ALIBABACLOUD_CLOUDAUTH_EXPORT InitFaceVerifyRequest : public RpcServiceReq
 public:
 	InitFaceVerifyRequest();
 	~InitFaceVerifyRequest();
-	std::string getBirthday() const;
-	void setBirthday(const std::string &birthday);
-	std::string getProductCode() const;
-	void setProductCode(const std::string &productCode);
 	std::string getFaceContrastPicture() const;
 	void setFaceContrastPicture(const std::string &faceContrastPicture);
 	std::string getReadImg() const;
@@ -44,36 +40,56 @@ public:
 	void setVoluntaryCustomizedContent(const std::string &voluntaryCustomizedContent);
 	std::string getUserId() const;
 	void setUserId(const std::string &userId);
-	std::string getCertifyId() const;
-	void setCertifyId(const std::string &certifyId);
 	std::string getEncryptType() const;
 	void setEncryptType(const std::string &encryptType);
 	std::string getMode() const;
 	void setMode(const std::string &mode);
-	std::string getCertNo() const;
-	void setCertNo(const std::string &certNo);
 	std::string getOuterOrderNo() const;
 	void setOuterOrderNo(const std::string &outerOrderNo);
-	std::string getCertType() const;
-	void setCertType(const std::string &certType);
 	std::string getFaceContrastPictureUrl() const;
 	void setFaceContrastPictureUrl(const std::string &faceContrastPictureUrl);
 	std::string getModel() const;
 	void setModel(const std::string &model);
-	std::string getSuitableType() const;
-	void setSuitableType(const std::string &suitableType);
 	std::string getCertifyUrlStyle() const;
 	void setCertifyUrlStyle(const std::string &certifyUrlStyle);
 	std::string getMetaInfo() const;
 	void setMetaInfo(const std::string &metaInfo);
-	std::string getOssObjectName() const;
-	void setOssObjectName(const std::string &ossObjectName);
+	std::string getCameraSelection() const;
+	void setCameraSelection(const std::string &cameraSelection);
 	std::string getValidityDate() const;
 	void setValidityDate(const std::string &validityDate);
 	std::string getCertName() const;
 	void setCertName(const std::string &certName);
 	std::string getIp() const;
 	void setIp(const std::string &ip);
+	long getSceneId() const;
+	void setSceneId(long sceneId);
+	std::string getOssBucketName() const;
+	void setOssBucketName(const std::string &ossBucketName);
+	std::string getCrop() const;
+	void setCrop(const std::string &crop);
+	std::string getCertifyUrlType() const;
+	void setCertifyUrlType(const std::string &certifyUrlType);
+	std::string getBirthday() const;
+	void setBirthday(const std::string &birthday);
+	std::string getExperienceCode() const;
+	void setExperienceCode(const std::string &experienceCode);
+	std::string getProductCode() const;
+	void setProductCode(const std::string &productCode);
+	std::string getVideoEvidence() const;
+	void setVideoEvidence(const std::string &videoEvidence);
+	std::string getCertifyId() const;
+	void setCertifyId(const std::string &certifyId);
+	std::string getCertNo() const;
+	void setCertNo(const std::string &certNo);
+	std::string getCertType() const;
+	void setCertType(const std::string &certType);
+	std::string getSuitableType() const;
+	void setSuitableType(const std::string &suitableType);
+	std::string getOssObjectName() const;
+	void setOssObjectName(const std::string &ossObjectName);
+	std::string getAppQualityCheck() const;
+	void setAppQualityCheck(const std::string &appQualityCheck);
 	std::string getMobile() const;
 	void setMobile(const std::string &mobile);
 	std::string getFaceGuardOutput() const;
@@ -82,55 +98,54 @@ public:
 	void setAuthId(const std::string &authId);
 	std::string getProcedurePriority() const;
 	void setProcedurePriority(const std::string &procedurePriority);
-	long getSceneId() const;
-	void setSceneId(long sceneId);
-	std::string getOssBucketName() const;
-	void setOssBucketName(const std::string &ossBucketName);
 	std::string getCallbackToken() const;
 	void setCallbackToken(const std::string &callbackToken);
+	std::string getUiCustomUrl() const;
+	void setUiCustomUrl(const std::string &uiCustomUrl);
 	std::string getReturnUrl() const;
 	void setReturnUrl(const std::string &returnUrl);
 	std::string getCallbackUrl() const;
 	void setCallbackUrl(const std::string &callbackUrl);
-	std::string getCrop() const;
-	void setCrop(const std::string &crop);
-	std::string getCertifyUrlType() const;
-	void setCertifyUrlType(const std::string &certifyUrlType);
 
 private:
-	std::string birthday_;
-	std::string productCode_;
 	std::string faceContrastPicture_;
 	std::string readImg_;
 	std::string rarelyCharacters_;
 	std::string voluntaryCustomizedContent_;
 	std::string userId_;
-	std::string certifyId_;
 	std::string encryptType_;
 	std::string mode_;
-	std::string certNo_;
 	std::string outerOrderNo_;
-	std::string certType_;
 	std::string faceContrastPictureUrl_;
 	std::string model_;
-	std::string suitableType_;
 	std::string certifyUrlStyle_;
 	std::string metaInfo_;
-	std::string ossObjectName_;
+	std::string cameraSelection_;
 	std::string validityDate_;
 	std::string certName_;
 	std::string ip_;
+	long sceneId_;
+	std::string ossBucketName_;
+	std::string crop_;
+	std::string certifyUrlType_;
+	std::string birthday_;
+	std::string experienceCode_;
+	std::string productCode_;
+	std::string videoEvidence_;
+	std::string certifyId_;
+	std::string certNo_;
+	std::string certType_;
+	std::string suitableType_;
+	std::string ossObjectName_;
+	std::string appQualityCheck_;
 	std::string mobile_;
 	std::string faceGuardOutput_;
 	std::string authId_;
 	std::string procedurePriority_;
-	long sceneId_;
-	std::string ossBucketName_;
 	std::string callbackToken_;
+	std::string uiCustomUrl_;
 	std::string returnUrl_;
 	std::string callbackUrl_;
-	std::string crop_;
-	std::string certifyUrlType_;
 };
 } // namespace Model
 } // namespace Cloudauth

cloudauth/include/alibabacloud/cloudauth/model/InsertWhiteListSettingRequest.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_CLOUDAUTH_MODEL_INSERTWHITELISTSETTINGREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_INSERTWHITELISTSETTINGREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT InsertWhiteListSettingRequest : public RpcServiceRequest {
+public:
+	InsertWhiteListSettingRequest();
+	~InsertWhiteListSettingRequest();
+	int getValidDay() const;
+	void setValidDay(int validDay);
+	std::string getRemark() const;
+	void setRemark(const std::string &remark);
+	std::string getCertifyId() const;
+	void setCertifyId(const std::string &certifyId);
+	std::string getCertNo() const;
+	void setCertNo(const std::string &certNo);
+	std::string getServiceCode() const;
+	void setServiceCode(const std::string &serviceCode);
+	long getSceneId() const;
+	void setSceneId(long sceneId);
+
+private:
+	int validDay_;
+	std::string remark_;
+	std::string certifyId_;
+	std::string certNo_;
+	std::string serviceCode_;
+	long sceneId_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_INSERTWHITELISTSETTINGREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/InsertWhiteListSettingResult.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_CLOUDAUTH_MODEL_INSERTWHITELISTSETTINGRESULT_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_INSERTWHITELISTSETTINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cloudauth
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLOUDAUTH_EXPORT InsertWhiteListSettingResult : public ServiceResult
+			{
+			public:
+
+
+				InsertWhiteListSettingResult();
+				explicit InsertWhiteListSettingResult(const std::string &payload);
+				~InsertWhiteListSettingResult();
+				bool getResultObject()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool resultObject_;
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_INSERTWHITELISTSETTINGRESULT_H_

cloudauth/include/alibabacloud/cloudauth/model/Mobile3MetaDetailStandardVerifyRequest.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_CLOUDAUTH_MODEL_MOBILE3METADETAILSTANDARDVERIFYREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILE3METADETAILSTANDARDVERIFYREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT Mobile3MetaDetailStandardVerifyRequest : public RpcServiceRequest {
+public:
+	Mobile3MetaDetailStandardVerifyRequest();
+	~Mobile3MetaDetailStandardVerifyRequest();
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getMobile() const;
+	void setMobile(const std::string &mobile);
+	std::string getIdentifyNum() const;
+	void setIdentifyNum(const std::string &identifyNum);
+	std::string getUserName() const;
+	void setUserName(const std::string &userName);
+
+private:
+	std::string paramType_;
+	std::string mobile_;
+	std::string identifyNum_;
+	std::string userName_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILE3METADETAILSTANDARDVERIFYREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/Mobile3MetaDetailStandardVerifyResult.h

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

cloudauth/include/alibabacloud/cloudauth/model/Mobile3MetaSimpleStandardVerifyRequest.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_CLOUDAUTH_MODEL_MOBILE3METASIMPLESTANDARDVERIFYREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILE3METASIMPLESTANDARDVERIFYREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT Mobile3MetaSimpleStandardVerifyRequest : public RpcServiceRequest {
+public:
+	Mobile3MetaSimpleStandardVerifyRequest();
+	~Mobile3MetaSimpleStandardVerifyRequest();
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getMobile() const;
+	void setMobile(const std::string &mobile);
+	std::string getIdentifyNum() const;
+	void setIdentifyNum(const std::string &identifyNum);
+	std::string getUserName() const;
+	void setUserName(const std::string &userName);
+
+private:
+	std::string paramType_;
+	std::string mobile_;
+	std::string identifyNum_;
+	std::string userName_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILE3METASIMPLESTANDARDVERIFYREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/Mobile3MetaSimpleStandardVerifyResult.h

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

cloudauth/include/alibabacloud/cloudauth/model/MobileDetectRequest.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_CLOUDAUTH_MODEL_MOBILEDETECTREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILEDETECTREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT MobileDetectRequest : public RpcServiceRequest {
+public:
+	MobileDetectRequest();
+	~MobileDetectRequest();
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getMobiles() const;
+	void setMobiles(const std::string &mobiles);
+
+private:
+	std::string paramType_;
+	std::string mobiles_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILEDETECTREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/MobileDetectResult.h

@@ -0,0 +1,68 @@
+/*
+ * 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_CLOUDAUTH_MODEL_MOBILEDETECTRESULT_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILEDETECTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cloudauth
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLOUDAUTH_EXPORT MobileDetectResult : public ServiceResult
+			{
+			public:
+				struct ResultObject
+				{
+					struct ItemsItem
+					{
+						std::string ispName;
+						std::string area;
+						std::string subCode;
+						std::string mobile;
+						std::string bizCode;
+					};
+					std::vector<ItemsItem> items;
+					std::string chargeCount;
+				};
+
+
+				MobileDetectResult();
+				explicit MobileDetectResult(const std::string &payload);
+				~MobileDetectResult();
+				ResultObject getResultObject()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ResultObject resultObject_;
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILEDETECTRESULT_H_

cloudauth/include/alibabacloud/cloudauth/model/MobileOnlineStatusRequest.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_CLOUDAUTH_MODEL_MOBILEONLINESTATUSREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILEONLINESTATUSREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT MobileOnlineStatusRequest : public RpcServiceRequest {
+public:
+	MobileOnlineStatusRequest();
+	~MobileOnlineStatusRequest();
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getMobile() const;
+	void setMobile(const std::string &mobile);
+
+private:
+	std::string paramType_;
+	std::string mobile_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILEONLINESTATUSREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/MobileOnlineStatusResult.h

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

cloudauth/include/alibabacloud/cloudauth/model/MobileOnlineTimeRequest.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_CLOUDAUTH_MODEL_MOBILEONLINETIMEREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILEONLINETIMEREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT MobileOnlineTimeRequest : public RpcServiceRequest {
+public:
+	MobileOnlineTimeRequest();
+	~MobileOnlineTimeRequest();
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getMobile() const;
+	void setMobile(const std::string &mobile);
+
+private:
+	std::string paramType_;
+	std::string mobile_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_MOBILEONLINETIMEREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/MobileOnlineTimeResult.h

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

cloudauth/include/alibabacloud/cloudauth/model/PageQueryWhiteListSettingRequest.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_CLOUDAUTH_MODEL_PAGEQUERYWHITELISTSETTINGREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_PAGEQUERYWHITELISTSETTINGREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT PageQueryWhiteListSettingRequest : public RpcServiceRequest {
+public:
+	PageQueryWhiteListSettingRequest();
+	~PageQueryWhiteListSettingRequest();
+	std::string getValidEndDate() const;
+	void setValidEndDate(const std::string &validEndDate);
+	std::string getCertifyId() const;
+	void setCertifyId(const std::string &certifyId);
+	std::string getCertNo() const;
+	void setCertNo(const std::string &certNo);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	int getCurrentPage() const;
+	void setCurrentPage(int currentPage);
+	std::string getServiceCode() const;
+	void setServiceCode(const std::string &serviceCode);
+	long getSceneId() const;
+	void setSceneId(long sceneId);
+	std::string getValidStartDate() const;
+	void setValidStartDate(const std::string &validStartDate);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	std::string validEndDate_;
+	std::string certifyId_;
+	std::string certNo_;
+	int pageSize_;
+	int currentPage_;
+	std::string serviceCode_;
+	long sceneId_;
+	std::string validStartDate_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_PAGEQUERYWHITELISTSETTINGREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/PageQueryWhiteListSettingResult.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CLOUDAUTH_MODEL_PAGEQUERYWHITELISTSETTINGRESULT_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_PAGEQUERYWHITELISTSETTINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cloudauth
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLOUDAUTH_EXPORT PageQueryWhiteListSettingResult : public ServiceResult
+			{
+			public:
+				struct ResultObjectItem
+				{
+					long sceneId;
+					std::string status;
+					std::string validEndDate;
+					std::string gmtCreate;
+					std::string validStartDate;
+					std::string serviceCode;
+					std::string certifyId;
+					std::string gmtModified;
+					long id;
+					std::string certNo;
+					std::string remark;
+				};
+
+
+				PageQueryWhiteListSettingResult();
+				explicit PageQueryWhiteListSettingResult(const std::string &payload);
+				~PageQueryWhiteListSettingResult();
+				std::vector<ResultObjectItem> getResultObject()const;
+				int getTotalItem()const;
+				std::string getMessage()const;
+				int getTotalPage()const;
+				int getPageSize()const;
+				int getCurrentPage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ResultObjectItem> resultObject_;
+				int totalItem_;
+				std::string message_;
+				int totalPage_;
+				int pageSize_;
+				int currentPage_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_PAGEQUERYWHITELISTSETTINGRESULT_H_

cloudauth/include/alibabacloud/cloudauth/model/RemoveWhiteListSettingRequest.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_CLOUDAUTH_MODEL_REMOVEWHITELISTSETTINGREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_REMOVEWHITELISTSETTINGREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT RemoveWhiteListSettingRequest : public RpcServiceRequest {
+public:
+	RemoveWhiteListSettingRequest();
+	~RemoveWhiteListSettingRequest();
+	std::string getServiceCode() const;
+	void setServiceCode(const std::string &serviceCode);
+	std::vector<long> getIds() const;
+	void setIds(const std::vector<long> &ids);
+
+private:
+	std::string serviceCode_;
+	std::vector<long> ids_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_REMOVEWHITELISTSETTINGREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/RemoveWhiteListSettingResult.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_CLOUDAUTH_MODEL_REMOVEWHITELISTSETTINGRESULT_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_REMOVEWHITELISTSETTINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cloudauth
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLOUDAUTH_EXPORT RemoveWhiteListSettingResult : public ServiceResult
+			{
+			public:
+
+
+				RemoveWhiteListSettingResult();
+				explicit RemoveWhiteListSettingResult(const std::string &payload);
+				~RemoveWhiteListSettingResult();
+				bool getResultObject()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool resultObject_;
+				std::string message_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_REMOVEWHITELISTSETTINGRESULT_H_

cloudauth/include/alibabacloud/cloudauth/model/Vehicle5ItemQueryRequest.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_CLOUDAUTH_MODEL_VEHICLE5ITEMQUERYREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLE5ITEMQUERYREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT Vehicle5ItemQueryRequest : public RpcServiceRequest {
+public:
+	Vehicle5ItemQueryRequest();
+	~Vehicle5ItemQueryRequest();
+	std::string getVehicleType() const;
+	void setVehicleType(const std::string &vehicleType);
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getVehicleNum() const;
+	void setVehicleNum(const std::string &vehicleNum);
+
+private:
+	std::string vehicleType_;
+	std::string paramType_;
+	std::string vehicleNum_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLE5ITEMQUERYREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/Vehicle5ItemQueryResult.h

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

cloudauth/include/alibabacloud/cloudauth/model/VehicleInsureQueryRequest.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_CLOUDAUTH_MODEL_VEHICLEINSUREQUERYREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLEINSUREQUERYREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT VehicleInsureQueryRequest : public RpcServiceRequest {
+public:
+	VehicleInsureQueryRequest();
+	~VehicleInsureQueryRequest();
+	std::string getVehicleType() const;
+	void setVehicleType(const std::string &vehicleType);
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getVehicleNum() const;
+	void setVehicleNum(const std::string &vehicleNum);
+	std::string getVin() const;
+	void setVin(const std::string &vin);
+
+private:
+	std::string vehicleType_;
+	std::string paramType_;
+	std::string vehicleNum_;
+	std::string vin_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLEINSUREQUERYREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/VehicleInsureQueryResult.h

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

cloudauth/include/alibabacloud/cloudauth/model/VehicleMetaVerifyRequest.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_CLOUDAUTH_MODEL_VEHICLEMETAVERIFYREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLEMETAVERIFYREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT VehicleMetaVerifyRequest : public RpcServiceRequest {
+public:
+	VehicleMetaVerifyRequest();
+	~VehicleMetaVerifyRequest();
+	std::string getVehicleType() const;
+	void setVehicleType(const std::string &vehicleType);
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getVehicleNum() const;
+	void setVehicleNum(const std::string &vehicleNum);
+	std::string getIdentifyNum() const;
+	void setIdentifyNum(const std::string &identifyNum);
+	std::string getVerifyMetaType() const;
+	void setVerifyMetaType(const std::string &verifyMetaType);
+	std::string getUserName() const;
+	void setUserName(const std::string &userName);
+
+private:
+	std::string vehicleType_;
+	std::string paramType_;
+	std::string vehicleNum_;
+	std::string identifyNum_;
+	std::string verifyMetaType_;
+	std::string userName_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLEMETAVERIFYREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/VehicleMetaVerifyResult.h

@@ -0,0 +1,59 @@
+/*
+ * 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_CLOUDAUTH_MODEL_VEHICLEMETAVERIFYRESULT_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLEMETAVERIFYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cloudauth
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CLOUDAUTH_EXPORT VehicleMetaVerifyResult : public ServiceResult
+			{
+			public:
+				struct ResultObject
+				{
+					std::string bizCode;
+				};
+
+
+				VehicleMetaVerifyResult();
+				explicit VehicleMetaVerifyResult(const std::string &payload);
+				~VehicleMetaVerifyResult();
+				ResultObject getResultObject()const;
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ResultObject resultObject_;
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLEMETAVERIFYRESULT_H_

cloudauth/include/alibabacloud/cloudauth/model/VehicleMetaVerifyV2Request.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_CLOUDAUTH_MODEL_VEHICLEMETAVERIFYV2REQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLEMETAVERIFYV2REQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT VehicleMetaVerifyV2Request : public RpcServiceRequest {
+public:
+	VehicleMetaVerifyV2Request();
+	~VehicleMetaVerifyV2Request();
+	std::string getVehicleType() const;
+	void setVehicleType(const std::string &vehicleType);
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getVehicleNum() const;
+	void setVehicleNum(const std::string &vehicleNum);
+	std::string getIdentifyNum() const;
+	void setIdentifyNum(const std::string &identifyNum);
+	std::string getVerifyMetaType() const;
+	void setVerifyMetaType(const std::string &verifyMetaType);
+	std::string getUserName() const;
+	void setUserName(const std::string &userName);
+
+private:
+	std::string vehicleType_;
+	std::string paramType_;
+	std::string vehicleNum_;
+	std::string identifyNum_;
+	std::string verifyMetaType_;
+	std::string userName_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLEMETAVERIFYV2REQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/VehicleMetaVerifyV2Result.h

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

cloudauth/include/alibabacloud/cloudauth/model/VehicleQueryRequest.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_CLOUDAUTH_MODEL_VEHICLEQUERYREQUEST_H_
+#define ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLEQUERYREQUEST_H_
+
+#include <alibabacloud/cloudauth/CloudauthExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cloudauth {
+namespace Model {
+class ALIBABACLOUD_CLOUDAUTH_EXPORT VehicleQueryRequest : public RpcServiceRequest {
+public:
+	VehicleQueryRequest();
+	~VehicleQueryRequest();
+	std::string getVehicleType() const;
+	void setVehicleType(const std::string &vehicleType);
+	std::string getParamType() const;
+	void setParamType(const std::string &paramType);
+	std::string getVehicleNum() const;
+	void setVehicleNum(const std::string &vehicleNum);
+
+private:
+	std::string vehicleType_;
+	std::string paramType_;
+	std::string vehicleNum_;
+};
+} // namespace Model
+} // namespace Cloudauth
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CLOUDAUTH_MODEL_VEHICLEQUERYREQUEST_H_

cloudauth/include/alibabacloud/cloudauth/model/VehicleQueryResult.h

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

cloudauth/src/CloudauthClient.cc

@@ -87,6 +87,42 @@ CloudauthClient::AIGCFaceVerifyOutcomeCallable CloudauthClient::aIGCFaceVerifyCa
 	return task->get_future();
 }
 
+CloudauthClient::BankMetaVerifyOutcome CloudauthClient::bankMetaVerify(const BankMetaVerifyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BankMetaVerifyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BankMetaVerifyOutcome(BankMetaVerifyResult(outcome.result()));
+	else
+		return BankMetaVerifyOutcome(outcome.error());
+}
+
+void CloudauthClient::bankMetaVerifyAsync(const BankMetaVerifyRequest& request, const BankMetaVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, bankMetaVerify(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::BankMetaVerifyOutcomeCallable CloudauthClient::bankMetaVerifyCallable(const BankMetaVerifyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BankMetaVerifyOutcome()>>(
+			[this, request]()
+			{
+			return this->bankMetaVerify(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CloudauthClient::CompareFaceVerifyOutcome CloudauthClient::compareFaceVerify(const CompareFaceVerifyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +303,114 @@ CloudauthClient::CreateVerifySettingOutcomeCallable CloudauthClient::createVerif
 	return task->get_future();
 }
 
+CloudauthClient::CredentialVerifyOutcome CloudauthClient::credentialVerify(const CredentialVerifyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CredentialVerifyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CredentialVerifyOutcome(CredentialVerifyResult(outcome.result()));
+	else
+		return CredentialVerifyOutcome(outcome.error());
+}
+
+void CloudauthClient::credentialVerifyAsync(const CredentialVerifyRequest& request, const CredentialVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, credentialVerify(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::CredentialVerifyOutcomeCallable CloudauthClient::credentialVerifyCallable(const CredentialVerifyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CredentialVerifyOutcome()>>(
+			[this, request]()
+			{
+			return this->credentialVerify(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CloudauthClient::DeepfakeDetectOutcome CloudauthClient::deepfakeDetect(const DeepfakeDetectRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeepfakeDetectOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeepfakeDetectOutcome(DeepfakeDetectResult(outcome.result()));
+	else
+		return DeepfakeDetectOutcome(outcome.error());
+}
+
+void CloudauthClient::deepfakeDetectAsync(const DeepfakeDetectRequest& request, const DeepfakeDetectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deepfakeDetect(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::DeepfakeDetectOutcomeCallable CloudauthClient::deepfakeDetectCallable(const DeepfakeDetectRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeepfakeDetectOutcome()>>(
+			[this, request]()
+			{
+			return this->deepfakeDetect(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CloudauthClient::DeleteFaceVerifyResultOutcome CloudauthClient::deleteFaceVerifyResult(const DeleteFaceVerifyResultRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteFaceVerifyResultOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteFaceVerifyResultOutcome(DeleteFaceVerifyResultResult(outcome.result()));
+	else
+		return DeleteFaceVerifyResultOutcome(outcome.error());
+}
+
+void CloudauthClient::deleteFaceVerifyResultAsync(const DeleteFaceVerifyResultRequest& request, const DeleteFaceVerifyResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteFaceVerifyResult(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::DeleteFaceVerifyResultOutcomeCallable CloudauthClient::deleteFaceVerifyResultCallable(const DeleteFaceVerifyResultRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteFaceVerifyResultOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteFaceVerifyResult(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CloudauthClient::DescribeDeviceInfoOutcome CloudauthClient::describeDeviceInfo(const DescribeDeviceInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +447,42 @@ CloudauthClient::DescribeDeviceInfoOutcomeCallable CloudauthClient::describeDevi
 	return task->get_future();
 }
 
+CloudauthClient::DescribeFaceGuardRiskOutcome CloudauthClient::describeFaceGuardRisk(const DescribeFaceGuardRiskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeFaceGuardRiskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeFaceGuardRiskOutcome(DescribeFaceGuardRiskResult(outcome.result()));
+	else
+		return DescribeFaceGuardRiskOutcome(outcome.error());
+}
+
+void CloudauthClient::describeFaceGuardRiskAsync(const DescribeFaceGuardRiskRequest& request, const DescribeFaceGuardRiskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeFaceGuardRisk(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::DescribeFaceGuardRiskOutcomeCallable CloudauthClient::describeFaceGuardRiskCallable(const DescribeFaceGuardRiskRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeFaceGuardRiskOutcome()>>(
+			[this, request]()
+			{
+			return this->describeFaceGuardRisk(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CloudauthClient::DescribeFaceVerifyOutcome CloudauthClient::describeFaceVerify(const DescribeFaceVerifyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -591,6 +771,78 @@ CloudauthClient::DetectFaceAttributesOutcomeCallable CloudauthClient::detectFace
 	return task->get_future();
 }
 
+CloudauthClient::Id2MetaPeriodVerifyOutcome CloudauthClient::id2MetaPeriodVerify(const Id2MetaPeriodVerifyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return Id2MetaPeriodVerifyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return Id2MetaPeriodVerifyOutcome(Id2MetaPeriodVerifyResult(outcome.result()));
+	else
+		return Id2MetaPeriodVerifyOutcome(outcome.error());
+}
+
+void CloudauthClient::id2MetaPeriodVerifyAsync(const Id2MetaPeriodVerifyRequest& request, const Id2MetaPeriodVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, id2MetaPeriodVerify(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::Id2MetaPeriodVerifyOutcomeCallable CloudauthClient::id2MetaPeriodVerifyCallable(const Id2MetaPeriodVerifyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<Id2MetaPeriodVerifyOutcome()>>(
+			[this, request]()
+			{
+			return this->id2MetaPeriodVerify(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CloudauthClient::Id2MetaStandardVerifyOutcome CloudauthClient::id2MetaStandardVerify(const Id2MetaStandardVerifyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return Id2MetaStandardVerifyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return Id2MetaStandardVerifyOutcome(Id2MetaStandardVerifyResult(outcome.result()));
+	else
+		return Id2MetaStandardVerifyOutcome(outcome.error());
+}
+
+void CloudauthClient::id2MetaStandardVerifyAsync(const Id2MetaStandardVerifyRequest& request, const Id2MetaStandardVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, id2MetaStandardVerify(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::Id2MetaStandardVerifyOutcomeCallable CloudauthClient::id2MetaStandardVerifyCallable(const Id2MetaStandardVerifyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<Id2MetaStandardVerifyOutcome()>>(
+			[this, request]()
+			{
+			return this->id2MetaStandardVerify(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CloudauthClient::Id2MetaVerifyOutcome CloudauthClient::id2MetaVerify(const Id2MetaVerifyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -663,6 +915,42 @@ CloudauthClient::InitFaceVerifyOutcomeCallable CloudauthClient::initFaceVerifyCa
 	return task->get_future();
 }
 
+CloudauthClient::InsertWhiteListSettingOutcome CloudauthClient::insertWhiteListSetting(const InsertWhiteListSettingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return InsertWhiteListSettingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return InsertWhiteListSettingOutcome(InsertWhiteListSettingResult(outcome.result()));
+	else
+		return InsertWhiteListSettingOutcome(outcome.error());
+}
+
+void CloudauthClient::insertWhiteListSettingAsync(const InsertWhiteListSettingRequest& request, const InsertWhiteListSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, insertWhiteListSetting(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::InsertWhiteListSettingOutcomeCallable CloudauthClient::insertWhiteListSettingCallable(const InsertWhiteListSettingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<InsertWhiteListSettingOutcome()>>(
+			[this, request]()
+			{
+			return this->insertWhiteListSetting(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CloudauthClient::LivenessFaceVerifyOutcome CloudauthClient::livenessFaceVerify(const LivenessFaceVerifyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -699,6 +987,42 @@ CloudauthClient::LivenessFaceVerifyOutcomeCallable CloudauthClient::livenessFace
 	return task->get_future();
 }
 
+CloudauthClient::Mobile3MetaDetailStandardVerifyOutcome CloudauthClient::mobile3MetaDetailStandardVerify(const Mobile3MetaDetailStandardVerifyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return Mobile3MetaDetailStandardVerifyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return Mobile3MetaDetailStandardVerifyOutcome(Mobile3MetaDetailStandardVerifyResult(outcome.result()));
+	else
+		return Mobile3MetaDetailStandardVerifyOutcome(outcome.error());
+}
+
+void CloudauthClient::mobile3MetaDetailStandardVerifyAsync(const Mobile3MetaDetailStandardVerifyRequest& request, const Mobile3MetaDetailStandardVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, mobile3MetaDetailStandardVerify(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::Mobile3MetaDetailStandardVerifyOutcomeCallable CloudauthClient::mobile3MetaDetailStandardVerifyCallable(const Mobile3MetaDetailStandardVerifyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<Mobile3MetaDetailStandardVerifyOutcome()>>(
+			[this, request]()
+			{
+			return this->mobile3MetaDetailStandardVerify(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CloudauthClient::Mobile3MetaDetailVerifyOutcome CloudauthClient::mobile3MetaDetailVerify(const Mobile3MetaDetailVerifyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -735,6 +1059,42 @@ CloudauthClient::Mobile3MetaDetailVerifyOutcomeCallable CloudauthClient::mobile3
 	return task->get_future();
 }
 
+CloudauthClient::Mobile3MetaSimpleStandardVerifyOutcome CloudauthClient::mobile3MetaSimpleStandardVerify(const Mobile3MetaSimpleStandardVerifyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return Mobile3MetaSimpleStandardVerifyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return Mobile3MetaSimpleStandardVerifyOutcome(Mobile3MetaSimpleStandardVerifyResult(outcome.result()));
+	else
+		return Mobile3MetaSimpleStandardVerifyOutcome(outcome.error());
+}
+
+void CloudauthClient::mobile3MetaSimpleStandardVerifyAsync(const Mobile3MetaSimpleStandardVerifyRequest& request, const Mobile3MetaSimpleStandardVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, mobile3MetaSimpleStandardVerify(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::Mobile3MetaSimpleStandardVerifyOutcomeCallable CloudauthClient::mobile3MetaSimpleStandardVerifyCallable(const Mobile3MetaSimpleStandardVerifyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<Mobile3MetaSimpleStandardVerifyOutcome()>>(
+			[this, request]()
+			{
+			return this->mobile3MetaSimpleStandardVerify(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CloudauthClient::Mobile3MetaSimpleVerifyOutcome CloudauthClient::mobile3MetaSimpleVerify(const Mobile3MetaSimpleVerifyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -771,6 +1131,114 @@ CloudauthClient::Mobile3MetaSimpleVerifyOutcomeCallable CloudauthClient::mobile3
 	return task->get_future();
 }
 
+CloudauthClient::MobileDetectOutcome CloudauthClient::mobileDetect(const MobileDetectRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return MobileDetectOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return MobileDetectOutcome(MobileDetectResult(outcome.result()));
+	else
+		return MobileDetectOutcome(outcome.error());
+}
+
+void CloudauthClient::mobileDetectAsync(const MobileDetectRequest& request, const MobileDetectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, mobileDetect(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::MobileDetectOutcomeCallable CloudauthClient::mobileDetectCallable(const MobileDetectRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<MobileDetectOutcome()>>(
+			[this, request]()
+			{
+			return this->mobileDetect(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CloudauthClient::MobileOnlineStatusOutcome CloudauthClient::mobileOnlineStatus(const MobileOnlineStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return MobileOnlineStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return MobileOnlineStatusOutcome(MobileOnlineStatusResult(outcome.result()));
+	else
+		return MobileOnlineStatusOutcome(outcome.error());
+}
+
+void CloudauthClient::mobileOnlineStatusAsync(const MobileOnlineStatusRequest& request, const MobileOnlineStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, mobileOnlineStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::MobileOnlineStatusOutcomeCallable CloudauthClient::mobileOnlineStatusCallable(const MobileOnlineStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<MobileOnlineStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->mobileOnlineStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CloudauthClient::MobileOnlineTimeOutcome CloudauthClient::mobileOnlineTime(const MobileOnlineTimeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return MobileOnlineTimeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return MobileOnlineTimeOutcome(MobileOnlineTimeResult(outcome.result()));
+	else
+		return MobileOnlineTimeOutcome(outcome.error());
+}
+
+void CloudauthClient::mobileOnlineTimeAsync(const MobileOnlineTimeRequest& request, const MobileOnlineTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, mobileOnlineTime(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::MobileOnlineTimeOutcomeCallable CloudauthClient::mobileOnlineTimeCallable(const MobileOnlineTimeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<MobileOnlineTimeOutcome()>>(
+			[this, request]()
+			{
+			return this->mobileOnlineTime(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CloudauthClient::ModifyDeviceInfoOutcome CloudauthClient::modifyDeviceInfo(const ModifyDeviceInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +1275,258 @@ CloudauthClient::ModifyDeviceInfoOutcomeCallable CloudauthClient::modifyDeviceIn
 	return task->get_future();
 }
 
+CloudauthClient::PageQueryWhiteListSettingOutcome CloudauthClient::pageQueryWhiteListSetting(const PageQueryWhiteListSettingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PageQueryWhiteListSettingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PageQueryWhiteListSettingOutcome(PageQueryWhiteListSettingResult(outcome.result()));
+	else
+		return PageQueryWhiteListSettingOutcome(outcome.error());
+}
+
+void CloudauthClient::pageQueryWhiteListSettingAsync(const PageQueryWhiteListSettingRequest& request, const PageQueryWhiteListSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, pageQueryWhiteListSetting(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::PageQueryWhiteListSettingOutcomeCallable CloudauthClient::pageQueryWhiteListSettingCallable(const PageQueryWhiteListSettingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PageQueryWhiteListSettingOutcome()>>(
+			[this, request]()
+			{
+			return this->pageQueryWhiteListSetting(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CloudauthClient::RemoveWhiteListSettingOutcome CloudauthClient::removeWhiteListSetting(const RemoveWhiteListSettingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveWhiteListSettingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveWhiteListSettingOutcome(RemoveWhiteListSettingResult(outcome.result()));
+	else
+		return RemoveWhiteListSettingOutcome(outcome.error());
+}
+
+void CloudauthClient::removeWhiteListSettingAsync(const RemoveWhiteListSettingRequest& request, const RemoveWhiteListSettingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeWhiteListSetting(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::RemoveWhiteListSettingOutcomeCallable CloudauthClient::removeWhiteListSettingCallable(const RemoveWhiteListSettingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveWhiteListSettingOutcome()>>(
+			[this, request]()
+			{
+			return this->removeWhiteListSetting(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CloudauthClient::Vehicle5ItemQueryOutcome CloudauthClient::vehicle5ItemQuery(const Vehicle5ItemQueryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return Vehicle5ItemQueryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return Vehicle5ItemQueryOutcome(Vehicle5ItemQueryResult(outcome.result()));
+	else
+		return Vehicle5ItemQueryOutcome(outcome.error());
+}
+
+void CloudauthClient::vehicle5ItemQueryAsync(const Vehicle5ItemQueryRequest& request, const Vehicle5ItemQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, vehicle5ItemQuery(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::Vehicle5ItemQueryOutcomeCallable CloudauthClient::vehicle5ItemQueryCallable(const Vehicle5ItemQueryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<Vehicle5ItemQueryOutcome()>>(
+			[this, request]()
+			{
+			return this->vehicle5ItemQuery(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CloudauthClient::VehicleInsureQueryOutcome CloudauthClient::vehicleInsureQuery(const VehicleInsureQueryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VehicleInsureQueryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VehicleInsureQueryOutcome(VehicleInsureQueryResult(outcome.result()));
+	else
+		return VehicleInsureQueryOutcome(outcome.error());
+}
+
+void CloudauthClient::vehicleInsureQueryAsync(const VehicleInsureQueryRequest& request, const VehicleInsureQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, vehicleInsureQuery(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::VehicleInsureQueryOutcomeCallable CloudauthClient::vehicleInsureQueryCallable(const VehicleInsureQueryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VehicleInsureQueryOutcome()>>(
+			[this, request]()
+			{
+			return this->vehicleInsureQuery(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CloudauthClient::VehicleMetaVerifyOutcome CloudauthClient::vehicleMetaVerify(const VehicleMetaVerifyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VehicleMetaVerifyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VehicleMetaVerifyOutcome(VehicleMetaVerifyResult(outcome.result()));
+	else
+		return VehicleMetaVerifyOutcome(outcome.error());
+}
+
+void CloudauthClient::vehicleMetaVerifyAsync(const VehicleMetaVerifyRequest& request, const VehicleMetaVerifyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, vehicleMetaVerify(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::VehicleMetaVerifyOutcomeCallable CloudauthClient::vehicleMetaVerifyCallable(const VehicleMetaVerifyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VehicleMetaVerifyOutcome()>>(
+			[this, request]()
+			{
+			return this->vehicleMetaVerify(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CloudauthClient::VehicleMetaVerifyV2Outcome CloudauthClient::vehicleMetaVerifyV2(const VehicleMetaVerifyV2Request &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VehicleMetaVerifyV2Outcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VehicleMetaVerifyV2Outcome(VehicleMetaVerifyV2Result(outcome.result()));
+	else
+		return VehicleMetaVerifyV2Outcome(outcome.error());
+}
+
+void CloudauthClient::vehicleMetaVerifyV2Async(const VehicleMetaVerifyV2Request& request, const VehicleMetaVerifyV2AsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, vehicleMetaVerifyV2(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::VehicleMetaVerifyV2OutcomeCallable CloudauthClient::vehicleMetaVerifyV2Callable(const VehicleMetaVerifyV2Request &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VehicleMetaVerifyV2Outcome()>>(
+			[this, request]()
+			{
+			return this->vehicleMetaVerifyV2(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CloudauthClient::VehicleQueryOutcome CloudauthClient::vehicleQuery(const VehicleQueryRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VehicleQueryOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VehicleQueryOutcome(VehicleQueryResult(outcome.result()));
+	else
+		return VehicleQueryOutcome(outcome.error());
+}
+
+void CloudauthClient::vehicleQueryAsync(const VehicleQueryRequest& request, const VehicleQueryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, vehicleQuery(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CloudauthClient::VehicleQueryOutcomeCallable CloudauthClient::vehicleQueryCallable(const VehicleQueryRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VehicleQueryOutcome()>>(
+			[this, request]()
+			{
+			return this->vehicleQuery(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CloudauthClient::VerifyMaterialOutcome CloudauthClient::verifyMaterial(const VerifyMaterialRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

cloudauth/src/model/BankMetaVerifyRequest.cc

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/cloudauth/model/BankMetaVerifyRequest.h>
+
+using AlibabaCloud::Cloudauth::Model::BankMetaVerifyRequest;
+
+BankMetaVerifyRequest::BankMetaVerifyRequest()
+    : RpcServiceRequest("cloudauth", "2019-03-07", "BankMetaVerify") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+BankMetaVerifyRequest::~BankMetaVerifyRequest() {}
+
+std::string BankMetaVerifyRequest::getParamType() const {
+  return paramType_;
+}
+
+void BankMetaVerifyRequest::setParamType(const std::string &paramType) {
+  paramType_ = paramType;
+  setParameter(std::string("ParamType"), paramType);
+}
+
+std::string BankMetaVerifyRequest::getVerifyMode() const {
+  return verifyMode_;
+}
+
+void BankMetaVerifyRequest::setVerifyMode(const std::string &verifyMode) {
+  verifyMode_ = verifyMode;
+  setParameter(std::string("VerifyMode"), verifyMode);
+}
+
+std::string BankMetaVerifyRequest::getIdentityType() const {
+  return identityType_;
+}
+
+void BankMetaVerifyRequest::setIdentityType(const std::string &identityType) {
+  identityType_ = identityType;
+  setParameter(std::string("IdentityType"), identityType);
+}
+
+std::string BankMetaVerifyRequest::getMobile() const {
+  return mobile_;
+}
+
+void BankMetaVerifyRequest::setMobile(const std::string &mobile) {
+  mobile_ = mobile;
+  setParameter(std::string("Mobile"), mobile);
+}
+
+std::string BankMetaVerifyRequest::getIdentifyNum() const {
+  return identifyNum_;
+}
+
+void BankMetaVerifyRequest::setIdentifyNum(const std::string &identifyNum) {
+  identifyNum_ = identifyNum;
+  setParameter(std::string("IdentifyNum"), identifyNum);
+}
+
+std::string BankMetaVerifyRequest::getProductType() const {
+  return productType_;
+}
+
+void BankMetaVerifyRequest::setProductType(const std::string &productType) {
+  productType_ = productType;
+  setParameter(std::string("ProductType"), productType);
+}
+
+std::string BankMetaVerifyRequest::getBankCard() const {
+  return bankCard_;
+}
+
+void BankMetaVerifyRequest::setBankCard(const std::string &bankCard) {
+  bankCard_ = bankCard;
+  setParameter(std::string("BankCard"), bankCard);
+}
+
+std::string BankMetaVerifyRequest::getUserName() const {
+  return userName_;
+}
+
+void BankMetaVerifyRequest::setUserName(const std::string &userName) {
+  userName_ = userName;
+  setParameter(std::string("UserName"), userName);
+}
+

cloudauth/src/model/BankMetaVerifyResult.cc

@@ -0,0 +1,68 @@
+/*
+ * 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/cloudauth/model/BankMetaVerifyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cloudauth;
+using namespace AlibabaCloud::Cloudauth::Model;
+
+BankMetaVerifyResult::BankMetaVerifyResult() :
+	ServiceResult()
+{}
+
+BankMetaVerifyResult::BankMetaVerifyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+BankMetaVerifyResult::~BankMetaVerifyResult()
+{}
+
+void BankMetaVerifyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultObjectNode = value["ResultObject"];
+	if(!resultObjectNode["BizCode"].isNull())
+		resultObject_.bizCode = resultObjectNode["BizCode"].asString();
+	if(!resultObjectNode["SubCode"].isNull())
+		resultObject_.subCode = resultObjectNode["SubCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+BankMetaVerifyResult::ResultObject BankMetaVerifyResult::getResultObject()const
+{
+	return resultObject_;
+}
+
+std::string BankMetaVerifyResult::getMessage()const
+{
+	return message_;
+}
+
+std::string BankMetaVerifyResult::getCode()const
+{
+	return code_;
+}
+

cloudauth/src/model/CredentialVerifyRequest.cc

@@ -0,0 +1,156 @@
+/*
+ * 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/cloudauth/model/CredentialVerifyRequest.h>
+
+using AlibabaCloud::Cloudauth::Model::CredentialVerifyRequest;
+
+CredentialVerifyRequest::CredentialVerifyRequest()
+    : RpcServiceRequest("cloudauth", "2019-03-07", "CredentialVerify") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CredentialVerifyRequest::~CredentialVerifyRequest() {}
+
+std::string CredentialVerifyRequest::getProductCode() const {
+  return productCode_;
+}
+
+void CredentialVerifyRequest::setProductCode(const std::string &productCode) {
+  productCode_ = productCode;
+  setParameter(std::string("ProductCode"), productCode);
+}
+
+std::string CredentialVerifyRequest::getIsOCR() const {
+  return isOCR_;
+}
+
+void CredentialVerifyRequest::setIsOCR(const std::string &isOCR) {
+  isOCR_ = isOCR;
+  setParameter(std::string("IsOCR"), isOCR);
+}
+
+std::string CredentialVerifyRequest::getIsCheck() const {
+  return isCheck_;
+}
+
+void CredentialVerifyRequest::setIsCheck(const std::string &isCheck) {
+  isCheck_ = isCheck;
+  setParameter(std::string("IsCheck"), isCheck);
+}
+
+std::string CredentialVerifyRequest::getImageContext() const {
+  return imageContext_;
+}
+
+void CredentialVerifyRequest::setImageContext(const std::string &imageContext) {
+  imageContext_ = imageContext;
+  setBodyParameter(std::string("ImageContext"), imageContext);
+}
+
+std::string CredentialVerifyRequest::getCredType() const {
+  return credType_;
+}
+
+void CredentialVerifyRequest::setCredType(const std::string &credType) {
+  credType_ = credType;
+  setParameter(std::string("CredType"), credType);
+}
+
+std::string CredentialVerifyRequest::getPromptModel() const {
+  return promptModel_;
+}
+
+void CredentialVerifyRequest::setPromptModel(const std::string &promptModel) {
+  promptModel_ = promptModel;
+  setParameter(std::string("PromptModel"), promptModel);
+}
+
+std::string CredentialVerifyRequest::getIdentifyNum() const {
+  return identifyNum_;
+}
+
+void CredentialVerifyRequest::setIdentifyNum(const std::string &identifyNum) {
+  identifyNum_ = identifyNum;
+  setParameter(std::string("IdentifyNum"), identifyNum);
+}
+
+std::string CredentialVerifyRequest::getCredName() const {
+  return credName_;
+}
+
+void CredentialVerifyRequest::setCredName(const std::string &credName) {
+  credName_ = credName;
+  setParameter(std::string("CredName"), credName);
+}
+
+std::string CredentialVerifyRequest::getMerchantId() const {
+  return merchantId_;
+}
+
+void CredentialVerifyRequest::setMerchantId(const std::string &merchantId) {
+  merchantId_ = merchantId;
+  setParameter(std::string("MerchantId"), merchantId);
+}
+
+std::vector<CredentialVerifyRequest::MerchantDetail> CredentialVerifyRequest::getMerchantDetail() const {
+  return merchantDetail_;
+}
+
+void CredentialVerifyRequest::setMerchantDetail(const std::vector<CredentialVerifyRequest::MerchantDetail> &merchantDetail) {
+  merchantDetail_ = merchantDetail;
+  for(int dep1 = 0; dep1 != merchantDetail.size(); dep1++) {
+    setParameter(std::string("MerchantDetail") + "." + std::to_string(dep1 + 1) + ".Value", merchantDetail[dep1].value);
+    setParameter(std::string("MerchantDetail") + "." + std::to_string(dep1 + 1) + ".Key", merchantDetail[dep1].key);
+  }
+}
+
+std::string CredentialVerifyRequest::getImageUrl() const {
+  return imageUrl_;
+}
+
+void CredentialVerifyRequest::setImageUrl(const std::string &imageUrl) {
+  imageUrl_ = imageUrl;
+  setParameter(std::string("ImageUrl"), imageUrl);
+}
+
+std::string CredentialVerifyRequest::getCertNum() const {
+  return certNum_;
+}
+
+void CredentialVerifyRequest::setCertNum(const std::string &certNum) {
+  certNum_ = certNum;
+  setParameter(std::string("CertNum"), certNum);
+}
+
+std::string CredentialVerifyRequest::getPrompt() const {
+  return prompt_;
+}
+
+void CredentialVerifyRequest::setPrompt(const std::string &prompt) {
+  prompt_ = prompt;
+  setParameter(std::string("Prompt"), prompt);
+}
+
+std::string CredentialVerifyRequest::getUserName() const {
+  return userName_;
+}
+
+void CredentialVerifyRequest::setUserName(const std::string &userName) {
+  userName_ = userName;
+  setParameter(std::string("UserName"), userName);
+}
+

cloudauth/src/model/CredentialVerifyResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/cloudauth/model/CredentialVerifyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cloudauth;
+using namespace AlibabaCloud::Cloudauth::Model;
+
+CredentialVerifyResult::CredentialVerifyResult() :
+	ServiceResult()
+{}
+
+CredentialVerifyResult::CredentialVerifyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CredentialVerifyResult::~CredentialVerifyResult()
+{}
+
+void CredentialVerifyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultObjectNode = value["ResultObject"];
+	if(!resultObjectNode["Result"].isNull())
+		resultObject_.result = resultObjectNode["Result"].asString();
+	if(!resultObjectNode["RiskTag"].isNull())
+		resultObject_.riskTag = resultObjectNode["RiskTag"].asString();
+	if(!resultObjectNode["RiskScore"].isNull())
+		resultObject_.riskScore = resultObjectNode["RiskScore"].asString();
+	if(!resultObjectNode["OcrInfo"].isNull())
+		resultObject_.ocrInfo = resultObjectNode["OcrInfo"].asString();
+	if(!resultObjectNode["VerifyResult"].isNull())
+		resultObject_.verifyResult = resultObjectNode["VerifyResult"].asString();
+	if(!resultObjectNode["VerifyDetail"].isNull())
+		resultObject_.verifyDetail = resultObjectNode["VerifyDetail"].asString();
+	if(!resultObjectNode["MaterialInfo"].isNull())
+		resultObject_.materialInfo = resultObjectNode["MaterialInfo"].asString();
+	auto vlResultNode = resultObjectNode["VlResult"];
+	if(!vlResultNode["Success"].isNull())
+		resultObject_.vlResult.success = vlResultNode["Success"].asString() == "true";
+	if(!vlResultNode["VlContent"].isNull())
+		resultObject_.vlResult.vlContent = vlResultNode["VlContent"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+CredentialVerifyResult::ResultObject CredentialVerifyResult::getResultObject()const
+{
+	return resultObject_;
+}
+
+std::string CredentialVerifyResult::getMessage()const
+{
+	return message_;
+}
+
+std::string CredentialVerifyResult::getCode()const
+{
+	return code_;
+}
+

cloudauth/src/model/DeepfakeDetectRequest.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/cloudauth/model/DeepfakeDetectRequest.h>
+
+using AlibabaCloud::Cloudauth::Model::DeepfakeDetectRequest;
+
+DeepfakeDetectRequest::DeepfakeDetectRequest()
+    : RpcServiceRequest("cloudauth", "2019-03-07", "DeepfakeDetect") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeepfakeDetectRequest::~DeepfakeDetectRequest() {}
+
+std::string DeepfakeDetectRequest::getFaceBase64() const {
+  return faceBase64_;
+}
+
+void DeepfakeDetectRequest::setFaceBase64(const std::string &faceBase64) {
+  faceBase64_ = faceBase64;
+  setBodyParameter(std::string("FaceBase64"), faceBase64);
+}
+
+std::string DeepfakeDetectRequest::getOuterOrderNo() const {
+  return outerOrderNo_;
+}
+
+void DeepfakeDetectRequest::setOuterOrderNo(const std::string &outerOrderNo) {
+  outerOrderNo_ = outerOrderNo;
+  setParameter(std::string("OuterOrderNo"), outerOrderNo);
+}
+
+std::string DeepfakeDetectRequest::getFaceUrl() const {
+  return faceUrl_;
+}
+
+void DeepfakeDetectRequest::setFaceUrl(const std::string &faceUrl) {
+  faceUrl_ = faceUrl;
+  setParameter(std::string("FaceUrl"), faceUrl);
+}
+
+std::string DeepfakeDetectRequest::getFaceInputType() const {
+  return faceInputType_;
+}
+
+void DeepfakeDetectRequest::setFaceInputType(const std::string &faceInputType) {
+  faceInputType_ = faceInputType;
+  setParameter(std::string("FaceInputType"), faceInputType);
+}
+

cloudauth/src/model/DeepfakeDetectResult.cc

@@ -0,0 +1,70 @@
+/*
+ * 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/cloudauth/model/DeepfakeDetectResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cloudauth;
+using namespace AlibabaCloud::Cloudauth::Model;
+
+DeepfakeDetectResult::DeepfakeDetectResult() :
+	ServiceResult()
+{}
+
+DeepfakeDetectResult::DeepfakeDetectResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeepfakeDetectResult::~DeepfakeDetectResult()
+{}
+
+void DeepfakeDetectResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultObjectNode = value["ResultObject"];
+	if(!resultObjectNode["Result"].isNull())
+		resultObject_.result = resultObjectNode["Result"].asString();
+	if(!resultObjectNode["RiskTag"].isNull())
+		resultObject_.riskTag = resultObjectNode["RiskTag"].asString();
+	if(!resultObjectNode["RiskScore"].isNull())
+		resultObject_.riskScore = resultObjectNode["RiskScore"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+DeepfakeDetectResult::ResultObject DeepfakeDetectResult::getResultObject()const
+{
+	return resultObject_;
+}
+
+std::string DeepfakeDetectResult::getMessage()const
+{
+	return message_;
+}
+
+std::string DeepfakeDetectResult::getCode()const
+{
+	return code_;
+}
+

cloudauth/src/model/DeleteFaceVerifyResultRequest.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/cloudauth/model/DeleteFaceVerifyResultRequest.h>
+
+using AlibabaCloud::Cloudauth::Model::DeleteFaceVerifyResultRequest;
+
+DeleteFaceVerifyResultRequest::DeleteFaceVerifyResultRequest()
+    : RpcServiceRequest("cloudauth", "2019-03-07", "DeleteFaceVerifyResult") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteFaceVerifyResultRequest::~DeleteFaceVerifyResultRequest() {}
+
+std::string DeleteFaceVerifyResultRequest::getDeleteAfterQuery() const {
+  return deleteAfterQuery_;
+}
+
+void DeleteFaceVerifyResultRequest::setDeleteAfterQuery(const std::string &deleteAfterQuery) {
+  deleteAfterQuery_ = deleteAfterQuery;
+  setParameter(std::string("DeleteAfterQuery"), deleteAfterQuery);
+}
+
+std::string DeleteFaceVerifyResultRequest::getCertifyId() const {
+  return certifyId_;
+}
+
+void DeleteFaceVerifyResultRequest::setCertifyId(const std::string &certifyId) {
+  certifyId_ = certifyId;
+  setParameter(std::string("CertifyId"), certifyId);
+}
+

cloudauth/src/model/DeleteFaceVerifyResultResult.cc

@@ -0,0 +1,70 @@
+/*
+ * 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/cloudauth/model/DeleteFaceVerifyResultResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cloudauth;
+using namespace AlibabaCloud::Cloudauth::Model;
+
+DeleteFaceVerifyResultResult::DeleteFaceVerifyResultResult() :
+	ServiceResult()
+{}
+
+DeleteFaceVerifyResultResult::DeleteFaceVerifyResultResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteFaceVerifyResultResult::~DeleteFaceVerifyResultResult()
+{}
+
+void DeleteFaceVerifyResultResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultObjectNode = value["ResultObject"];
+	if(!resultObjectNode["CertifyId"].isNull())
+		resultObject_.certifyId = resultObjectNode["CertifyId"].asString();
+	if(!resultObjectNode["DeleteResult"].isNull())
+		resultObject_.deleteResult = resultObjectNode["DeleteResult"].asString();
+	if(!resultObjectNode["FailReason"].isNull())
+		resultObject_.failReason = resultObjectNode["FailReason"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+DeleteFaceVerifyResultResult::ResultObject DeleteFaceVerifyResultResult::getResultObject()const
+{
+	return resultObject_;
+}
+
+std::string DeleteFaceVerifyResultResult::getMessage()const
+{
+	return message_;
+}
+
+std::string DeleteFaceVerifyResultResult::getCode()const
+{
+	return code_;
+}
+

cloudauth/src/model/DescribeFaceGuardRiskRequest.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/cloudauth/model/DescribeFaceGuardRiskRequest.h>
+
+using AlibabaCloud::Cloudauth::Model::DescribeFaceGuardRiskRequest;
+
+DescribeFaceGuardRiskRequest::DescribeFaceGuardRiskRequest()
+    : RpcServiceRequest("cloudauth", "2019-03-07", "DescribeFaceGuardRisk") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeFaceGuardRiskRequest::~DescribeFaceGuardRiskRequest() {}
+
+std::string DescribeFaceGuardRiskRequest::getProductCode() const {
+  return productCode_;
+}
+
+void DescribeFaceGuardRiskRequest::setProductCode(const std::string &productCode) {
+  productCode_ = productCode;
+  setParameter(std::string("ProductCode"), productCode);
+}
+
+std::string DescribeFaceGuardRiskRequest::getDeviceToken() const {
+  return deviceToken_;
+}
+
+void DescribeFaceGuardRiskRequest::setDeviceToken(const std::string &deviceToken) {
+  deviceToken_ = deviceToken;
+  setParameter(std::string("DeviceToken"), deviceToken);
+}
+
+std::string DescribeFaceGuardRiskRequest::getOuterOrderNo() const {
+  return outerOrderNo_;
+}
+
+void DescribeFaceGuardRiskRequest::setOuterOrderNo(const std::string &outerOrderNo) {
+  outerOrderNo_ = outerOrderNo;
+  setParameter(std::string("OuterOrderNo"), outerOrderNo);
+}
+
+std::string DescribeFaceGuardRiskRequest::getBizId() const {
+  return bizId_;
+}
+
+void DescribeFaceGuardRiskRequest::setBizId(const std::string &bizId) {
+  bizId_ = bizId;
+  setParameter(std::string("BizId"), bizId);
+}
+

cloudauth/src/model/DescribeFaceGuardRiskResult.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/cloudauth/model/DescribeFaceGuardRiskResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cloudauth;
+using namespace AlibabaCloud::Cloudauth::Model;
+
+DescribeFaceGuardRiskResult::DescribeFaceGuardRiskResult() :
+	ServiceResult()
+{}
+
+DescribeFaceGuardRiskResult::DescribeFaceGuardRiskResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeFaceGuardRiskResult::~DescribeFaceGuardRiskResult()
+{}
+
+void DescribeFaceGuardRiskResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultObjectNode = value["ResultObject"];
+	if(!resultObjectNode["RiakTags"].isNull())
+		resultObject_.riakTags = resultObjectNode["RiakTags"].asString();
+	if(!resultObjectNode["RiskExtends"].isNull())
+		resultObject_.riskExtends = resultObjectNode["RiskExtends"].asString();
+	if(!resultObjectNode["RiskTags"].isNull())
+		resultObject_.riskTags = resultObjectNode["RiskTags"].asString();
+	if(!resultObjectNode["CertifyId"].isNull())
+		resultObject_.certifyId = resultObjectNode["CertifyId"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+DescribeFaceGuardRiskResult::ResultObject DescribeFaceGuardRiskResult::getResultObject()const
+{
+	return resultObject_;
+}
+
+std::string DescribeFaceGuardRiskResult::getMessage()const
+{
+	return message_;
+}
+
+std::string DescribeFaceGuardRiskResult::getCode()const
+{
+	return code_;
+}
+

cloudauth/src/model/Id2MetaPeriodVerifyRequest.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/cloudauth/model/Id2MetaPeriodVerifyRequest.h>
+
+using AlibabaCloud::Cloudauth::Model::Id2MetaPeriodVerifyRequest;
+
+Id2MetaPeriodVerifyRequest::Id2MetaPeriodVerifyRequest()
+    : RpcServiceRequest("cloudauth", "2019-03-07", "Id2MetaPeriodVerify") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+Id2MetaPeriodVerifyRequest::~Id2MetaPeriodVerifyRequest() {}
+
+std::string Id2MetaPeriodVerifyRequest::getParamType() const {
+  return paramType_;
+}
+
+void Id2MetaPeriodVerifyRequest::setParamType(const std::string &paramType) {
+  paramType_ = paramType;
+  setBodyParameter(std::string("ParamType"), paramType);
+}
+
+std::string Id2MetaPeriodVerifyRequest::getValidityStartDate() const {
+  return validityStartDate_;
+}
+
+void Id2MetaPeriodVerifyRequest::setValidityStartDate(const std::string &validityStartDate) {
+  validityStartDate_ = validityStartDate;
+  setBodyParameter(std::string("ValidityStartDate"), validityStartDate);
+}
+
+std::string Id2MetaPeriodVerifyRequest::getValidityEndDate() const {
+  return validityEndDate_;
+}
+
+void Id2MetaPeriodVerifyRequest::setValidityEndDate(const std::string &validityEndDate) {
+  validityEndDate_ = validityEndDate;
+  setBodyParameter(std::string("ValidityEndDate"), validityEndDate);
+}
+
+std::string Id2MetaPeriodVerifyRequest::getIdentifyNum() const {
+  return identifyNum_;
+}
+
+void Id2MetaPeriodVerifyRequest::setIdentifyNum(const std::string &identifyNum) {
+  identifyNum_ = identifyNum;
+  setBodyParameter(std::string("IdentifyNum"), identifyNum);
+}
+
+std::string Id2MetaPeriodVerifyRequest::getUserName() const {
+  return userName_;
+}
+
+void Id2MetaPeriodVerifyRequest::setUserName(const std::string &userName) {
+  userName_ = userName;
+  setBodyParameter(std::string("UserName"), userName);
+}
+

cloudauth/src/model/Id2MetaPeriodVerifyResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/cloudauth/model/Id2MetaPeriodVerifyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cloudauth;
+using namespace AlibabaCloud::Cloudauth::Model;
+
+Id2MetaPeriodVerifyResult::Id2MetaPeriodVerifyResult() :
+	ServiceResult()
+{}
+
+Id2MetaPeriodVerifyResult::Id2MetaPeriodVerifyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+Id2MetaPeriodVerifyResult::~Id2MetaPeriodVerifyResult()
+{}
+
+void Id2MetaPeriodVerifyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultObjectNode = value["ResultObject"];
+	if(!resultObjectNode["BizCode"].isNull())
+		resultObject_.bizCode = resultObjectNode["BizCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+Id2MetaPeriodVerifyResult::ResultObject Id2MetaPeriodVerifyResult::getResultObject()const
+{
+	return resultObject_;
+}
+
+std::string Id2MetaPeriodVerifyResult::getMessage()const
+{
+	return message_;
+}
+
+std::string Id2MetaPeriodVerifyResult::getCode()const
+{
+	return code_;
+}
+

cloudauth/src/model/Id2MetaStandardVerifyRequest.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/cloudauth/model/Id2MetaStandardVerifyRequest.h>
+
+using AlibabaCloud::Cloudauth::Model::Id2MetaStandardVerifyRequest;
+
+Id2MetaStandardVerifyRequest::Id2MetaStandardVerifyRequest()
+    : RpcServiceRequest("cloudauth", "2019-03-07", "Id2MetaStandardVerify") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+Id2MetaStandardVerifyRequest::~Id2MetaStandardVerifyRequest() {}
+
+std::string Id2MetaStandardVerifyRequest::getParamType() const {
+  return paramType_;
+}
+
+void Id2MetaStandardVerifyRequest::setParamType(const std::string &paramType) {
+  paramType_ = paramType;
+  setBodyParameter(std::string("ParamType"), paramType);
+}
+
+std::string Id2MetaStandardVerifyRequest::getIdentifyNum() const {
+  return identifyNum_;
+}
+
+void Id2MetaStandardVerifyRequest::setIdentifyNum(const std::string &identifyNum) {
+  identifyNum_ = identifyNum;
+  setBodyParameter(std::string("IdentifyNum"), identifyNum);
+}
+
+std::string Id2MetaStandardVerifyRequest::getUserName() const {
+  return userName_;
+}
+
+void Id2MetaStandardVerifyRequest::setUserName(const std::string &userName) {
+  userName_ = userName;
+  setBodyParameter(std::string("UserName"), userName);
+}
+

cloudauth/src/model/Id2MetaStandardVerifyResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/cloudauth/model/Id2MetaStandardVerifyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cloudauth;
+using namespace AlibabaCloud::Cloudauth::Model;
+
+Id2MetaStandardVerifyResult::Id2MetaStandardVerifyResult() :
+	ServiceResult()
+{}
+
+Id2MetaStandardVerifyResult::Id2MetaStandardVerifyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+Id2MetaStandardVerifyResult::~Id2MetaStandardVerifyResult()
+{}
+
+void Id2MetaStandardVerifyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultObjectNode = value["ResultObject"];
+	if(!resultObjectNode["BizCode"].isNull())
+		resultObject_.bizCode = resultObjectNode["BizCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+Id2MetaStandardVerifyResult::ResultObject Id2MetaStandardVerifyResult::getResultObject()const
+{
+	return resultObject_;
+}
+
+std::string Id2MetaStandardVerifyResult::getMessage()const
+{
+	return message_;
+}
+
+std::string Id2MetaStandardVerifyResult::getCode()const
+{
+	return code_;
+}
+

cloudauth/src/model/Id2MetaVerifyRequest.cc

@@ -31,7 +31,7 @@ std::string Id2MetaVerifyRequest::getParamType() const {
 
 void Id2MetaVerifyRequest::setParamType(const std::string &paramType) {
   paramType_ = paramType;
-  setParameter(std::string("ParamType"), paramType);
+  setBodyParameter(std::string("ParamType"), paramType);
 }
 
 std::string Id2MetaVerifyRequest::getIdentifyNum() const {
@@ -40,7 +40,7 @@ std::string Id2MetaVerifyRequest::getIdentifyNum() const {
 
 void Id2MetaVerifyRequest::setIdentifyNum(const std::string &identifyNum) {
   identifyNum_ = identifyNum;
-  setParameter(std::string("IdentifyNum"), identifyNum);
+  setBodyParameter(std::string("IdentifyNum"), identifyNum);
 }
 
 std::string Id2MetaVerifyRequest::getUserName() const {
@@ -49,6 +49,6 @@ std::string Id2MetaVerifyRequest::getUserName() const {
 
 void Id2MetaVerifyRequest::setUserName(const std::string &userName) {
   userName_ = userName;
-  setParameter(std::string("UserName"), userName);
+  setBodyParameter(std::string("UserName"), userName);
 }