Support all language.

CHANGELOG

@@ -1,3 +1,6 @@
+2022-05-19 Version: 1.36.1129
+- Support all language.
+
 2022-05-16 Version: 1.36.1128
 - Add Api ListQualityCheckScheme.
 

VERSION

@@ -1 +1 @@
-1.36.1128
+1.36.1129

idaas-doraemon/CMakeLists.txt

@@ -0,0 +1,142 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(idaas-doraemon_public_header 
+	include/alibabacloud/idaas-doraemon/Idaas_doraemonClient.h
+	include/alibabacloud/idaas-doraemon/Idaas_doraemonExport.h )
+
+set(idaas-doraemon_public_header_model 
+	include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationRequest.h
+	include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationResult.h
+	include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsRequest.h
+	include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsResult.h
+	include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorRequest.h
+	include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorResult.h
+	include/alibabacloud/idaas-doraemon/model/FetchAccessTokenRequest.h
+	include/alibabacloud/idaas-doraemon/model/FetchAccessTokenResult.h
+	include/alibabacloud/idaas-doraemon/model/GetAuthenticatorRequest.h
+	include/alibabacloud/idaas-doraemon/model/GetAuthenticatorResult.h
+	include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsRequest.h
+	include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsResult.h
+	include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsRequest.h
+	include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsResult.h
+	include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsRequest.h
+	include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsResult.h
+	include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsRequest.h
+	include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsResult.h
+	include/alibabacloud/idaas-doraemon/model/ListUsersRequest.h
+	include/alibabacloud/idaas-doraemon/model/ListUsersResult.h
+	include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorRequest.h
+	include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorResult.h
+	include/alibabacloud/idaas-doraemon/model/ServiceInvokeRequest.h
+	include/alibabacloud/idaas-doraemon/model/ServiceInvokeResult.h
+	include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeRequest.h
+	include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeResult.h
+	include/alibabacloud/idaas-doraemon/model/VerifyIdTokenRequest.h
+	include/alibabacloud/idaas-doraemon/model/VerifyIdTokenResult.h
+	include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationRequest.h
+	include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationResult.h )
+
+set(idaas-doraemon_src 
+	src/Idaas-doraemonClient.cc
+	src/model/CreateAuthenticatorRegistrationRequest.cc
+	src/model/CreateAuthenticatorRegistrationResult.cc
+	src/model/CreateUserAuthenticateOptionsRequest.cc
+	src/model/CreateUserAuthenticateOptionsResult.cc
+	src/model/DeregisterAuthenticatorRequest.cc
+	src/model/DeregisterAuthenticatorResult.cc
+	src/model/FetchAccessTokenRequest.cc
+	src/model/FetchAccessTokenResult.cc
+	src/model/GetAuthenticatorRequest.cc
+	src/model/GetAuthenticatorResult.cc
+	src/model/ListAuthenticationLogsRequest.cc
+	src/model/ListAuthenticationLogsResult.cc
+	src/model/ListAuthenticatorOpsLogsRequest.cc
+	src/model/ListAuthenticatorOpsLogsResult.cc
+	src/model/ListAuthenticatorsRequest.cc
+	src/model/ListAuthenticatorsResult.cc
+	src/model/ListPwnedPasswordsRequest.cc
+	src/model/ListPwnedPasswordsResult.cc
+	src/model/ListUsersRequest.cc
+	src/model/ListUsersResult.cc
+	src/model/RegisterAuthenticatorRequest.cc
+	src/model/RegisterAuthenticatorResult.cc
+	src/model/ServiceInvokeRequest.cc
+	src/model/ServiceInvokeResult.cc
+	src/model/UpdateAuthenticatorAttributeRequest.cc
+	src/model/UpdateAuthenticatorAttributeResult.cc
+	src/model/VerifyIdTokenRequest.cc
+	src/model/VerifyIdTokenResult.cc
+	src/model/VerifyUserAuthenticationRequest.cc
+	src/model/VerifyUserAuthenticationResult.cc )
+
+add_library(idaas-doraemon ${LIB_TYPE}
+	${idaas-doraemon_public_header}
+	${idaas-doraemon_public_header_model}
+	${idaas-doraemon_src})
+
+set_target_properties(idaas-doraemon
+	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}idaas-doraemon
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(idaas-doraemon
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_IDAAS_DORAEMON_LIBRARY)
+endif()
+
+target_include_directories(idaas-doraemon
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(idaas-doraemon
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(idaas-doraemon
+		jsoncpp)
+	target_include_directories(idaas-doraemon
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(idaas-doraemon
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(idaas-doraemon
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(idaas-doraemon
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(idaas-doraemon
+		jsoncpp)
+endif()
+
+install(FILES ${idaas-doraemon_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/idaas-doraemon)
+install(FILES ${idaas-doraemon_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/idaas-doraemon/model)
+install(TARGETS idaas-doraemon
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

idaas-doraemon/include/alibabacloud/idaas-doraemon/Idaas_doraemonClient.h

@@ -0,0 +1,166 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_IDAAS_DORAEMON_IDAAS_DORAEMONCLIENT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_IDAAS_DORAEMONCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "Idaas_doraemonExport.h"
+#include "model/CreateAuthenticatorRegistrationRequest.h"
+#include "model/CreateAuthenticatorRegistrationResult.h"
+#include "model/CreateUserAuthenticateOptionsRequest.h"
+#include "model/CreateUserAuthenticateOptionsResult.h"
+#include "model/DeregisterAuthenticatorRequest.h"
+#include "model/DeregisterAuthenticatorResult.h"
+#include "model/FetchAccessTokenRequest.h"
+#include "model/FetchAccessTokenResult.h"
+#include "model/GetAuthenticatorRequest.h"
+#include "model/GetAuthenticatorResult.h"
+#include "model/ListAuthenticationLogsRequest.h"
+#include "model/ListAuthenticationLogsResult.h"
+#include "model/ListAuthenticatorOpsLogsRequest.h"
+#include "model/ListAuthenticatorOpsLogsResult.h"
+#include "model/ListAuthenticatorsRequest.h"
+#include "model/ListAuthenticatorsResult.h"
+#include "model/ListPwnedPasswordsRequest.h"
+#include "model/ListPwnedPasswordsResult.h"
+#include "model/ListUsersRequest.h"
+#include "model/ListUsersResult.h"
+#include "model/RegisterAuthenticatorRequest.h"
+#include "model/RegisterAuthenticatorResult.h"
+#include "model/ServiceInvokeRequest.h"
+#include "model/ServiceInvokeResult.h"
+#include "model/UpdateAuthenticatorAttributeRequest.h"
+#include "model/UpdateAuthenticatorAttributeResult.h"
+#include "model/VerifyIdTokenRequest.h"
+#include "model/VerifyIdTokenResult.h"
+#include "model/VerifyUserAuthenticationRequest.h"
+#include "model/VerifyUserAuthenticationResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT Idaas_doraemonClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::CreateAuthenticatorRegistrationResult> CreateAuthenticatorRegistrationOutcome;
+			typedef std::future<CreateAuthenticatorRegistrationOutcome> CreateAuthenticatorRegistrationOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::CreateAuthenticatorRegistrationRequest&, const CreateAuthenticatorRegistrationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAuthenticatorRegistrationAsyncHandler;
+			typedef Outcome<Error, Model::CreateUserAuthenticateOptionsResult> CreateUserAuthenticateOptionsOutcome;
+			typedef std::future<CreateUserAuthenticateOptionsOutcome> CreateUserAuthenticateOptionsOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::CreateUserAuthenticateOptionsRequest&, const CreateUserAuthenticateOptionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateUserAuthenticateOptionsAsyncHandler;
+			typedef Outcome<Error, Model::DeregisterAuthenticatorResult> DeregisterAuthenticatorOutcome;
+			typedef std::future<DeregisterAuthenticatorOutcome> DeregisterAuthenticatorOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::DeregisterAuthenticatorRequest&, const DeregisterAuthenticatorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeregisterAuthenticatorAsyncHandler;
+			typedef Outcome<Error, Model::FetchAccessTokenResult> FetchAccessTokenOutcome;
+			typedef std::future<FetchAccessTokenOutcome> FetchAccessTokenOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::FetchAccessTokenRequest&, const FetchAccessTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FetchAccessTokenAsyncHandler;
+			typedef Outcome<Error, Model::GetAuthenticatorResult> GetAuthenticatorOutcome;
+			typedef std::future<GetAuthenticatorOutcome> GetAuthenticatorOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::GetAuthenticatorRequest&, const GetAuthenticatorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAuthenticatorAsyncHandler;
+			typedef Outcome<Error, Model::ListAuthenticationLogsResult> ListAuthenticationLogsOutcome;
+			typedef std::future<ListAuthenticationLogsOutcome> ListAuthenticationLogsOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::ListAuthenticationLogsRequest&, const ListAuthenticationLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAuthenticationLogsAsyncHandler;
+			typedef Outcome<Error, Model::ListAuthenticatorOpsLogsResult> ListAuthenticatorOpsLogsOutcome;
+			typedef std::future<ListAuthenticatorOpsLogsOutcome> ListAuthenticatorOpsLogsOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::ListAuthenticatorOpsLogsRequest&, const ListAuthenticatorOpsLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAuthenticatorOpsLogsAsyncHandler;
+			typedef Outcome<Error, Model::ListAuthenticatorsResult> ListAuthenticatorsOutcome;
+			typedef std::future<ListAuthenticatorsOutcome> ListAuthenticatorsOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::ListAuthenticatorsRequest&, const ListAuthenticatorsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAuthenticatorsAsyncHandler;
+			typedef Outcome<Error, Model::ListPwnedPasswordsResult> ListPwnedPasswordsOutcome;
+			typedef std::future<ListPwnedPasswordsOutcome> ListPwnedPasswordsOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::ListPwnedPasswordsRequest&, const ListPwnedPasswordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPwnedPasswordsAsyncHandler;
+			typedef Outcome<Error, Model::ListUsersResult> ListUsersOutcome;
+			typedef std::future<ListUsersOutcome> ListUsersOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::ListUsersRequest&, const ListUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUsersAsyncHandler;
+			typedef Outcome<Error, Model::RegisterAuthenticatorResult> RegisterAuthenticatorOutcome;
+			typedef std::future<RegisterAuthenticatorOutcome> RegisterAuthenticatorOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::RegisterAuthenticatorRequest&, const RegisterAuthenticatorOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RegisterAuthenticatorAsyncHandler;
+			typedef Outcome<Error, Model::ServiceInvokeResult> ServiceInvokeOutcome;
+			typedef std::future<ServiceInvokeOutcome> ServiceInvokeOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::ServiceInvokeRequest&, const ServiceInvokeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ServiceInvokeAsyncHandler;
+			typedef Outcome<Error, Model::UpdateAuthenticatorAttributeResult> UpdateAuthenticatorAttributeOutcome;
+			typedef std::future<UpdateAuthenticatorAttributeOutcome> UpdateAuthenticatorAttributeOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::UpdateAuthenticatorAttributeRequest&, const UpdateAuthenticatorAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateAuthenticatorAttributeAsyncHandler;
+			typedef Outcome<Error, Model::VerifyIdTokenResult> VerifyIdTokenOutcome;
+			typedef std::future<VerifyIdTokenOutcome> VerifyIdTokenOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::VerifyIdTokenRequest&, const VerifyIdTokenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyIdTokenAsyncHandler;
+			typedef Outcome<Error, Model::VerifyUserAuthenticationResult> VerifyUserAuthenticationOutcome;
+			typedef std::future<VerifyUserAuthenticationOutcome> VerifyUserAuthenticationOutcomeCallable;
+			typedef std::function<void(const Idaas_doraemonClient*, const Model::VerifyUserAuthenticationRequest&, const VerifyUserAuthenticationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyUserAuthenticationAsyncHandler;
+
+			Idaas_doraemonClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			Idaas_doraemonClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			Idaas_doraemonClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~Idaas_doraemonClient();
+			CreateAuthenticatorRegistrationOutcome createAuthenticatorRegistration(const Model::CreateAuthenticatorRegistrationRequest &request)const;
+			void createAuthenticatorRegistrationAsync(const Model::CreateAuthenticatorRegistrationRequest& request, const CreateAuthenticatorRegistrationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAuthenticatorRegistrationOutcomeCallable createAuthenticatorRegistrationCallable(const Model::CreateAuthenticatorRegistrationRequest& request) const;
+			CreateUserAuthenticateOptionsOutcome createUserAuthenticateOptions(const Model::CreateUserAuthenticateOptionsRequest &request)const;
+			void createUserAuthenticateOptionsAsync(const Model::CreateUserAuthenticateOptionsRequest& request, const CreateUserAuthenticateOptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateUserAuthenticateOptionsOutcomeCallable createUserAuthenticateOptionsCallable(const Model::CreateUserAuthenticateOptionsRequest& request) const;
+			DeregisterAuthenticatorOutcome deregisterAuthenticator(const Model::DeregisterAuthenticatorRequest &request)const;
+			void deregisterAuthenticatorAsync(const Model::DeregisterAuthenticatorRequest& request, const DeregisterAuthenticatorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeregisterAuthenticatorOutcomeCallable deregisterAuthenticatorCallable(const Model::DeregisterAuthenticatorRequest& request) const;
+			FetchAccessTokenOutcome fetchAccessToken(const Model::FetchAccessTokenRequest &request)const;
+			void fetchAccessTokenAsync(const Model::FetchAccessTokenRequest& request, const FetchAccessTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			FetchAccessTokenOutcomeCallable fetchAccessTokenCallable(const Model::FetchAccessTokenRequest& request) const;
+			GetAuthenticatorOutcome getAuthenticator(const Model::GetAuthenticatorRequest &request)const;
+			void getAuthenticatorAsync(const Model::GetAuthenticatorRequest& request, const GetAuthenticatorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAuthenticatorOutcomeCallable getAuthenticatorCallable(const Model::GetAuthenticatorRequest& request) const;
+			ListAuthenticationLogsOutcome listAuthenticationLogs(const Model::ListAuthenticationLogsRequest &request)const;
+			void listAuthenticationLogsAsync(const Model::ListAuthenticationLogsRequest& request, const ListAuthenticationLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAuthenticationLogsOutcomeCallable listAuthenticationLogsCallable(const Model::ListAuthenticationLogsRequest& request) const;
+			ListAuthenticatorOpsLogsOutcome listAuthenticatorOpsLogs(const Model::ListAuthenticatorOpsLogsRequest &request)const;
+			void listAuthenticatorOpsLogsAsync(const Model::ListAuthenticatorOpsLogsRequest& request, const ListAuthenticatorOpsLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAuthenticatorOpsLogsOutcomeCallable listAuthenticatorOpsLogsCallable(const Model::ListAuthenticatorOpsLogsRequest& request) const;
+			ListAuthenticatorsOutcome listAuthenticators(const Model::ListAuthenticatorsRequest &request)const;
+			void listAuthenticatorsAsync(const Model::ListAuthenticatorsRequest& request, const ListAuthenticatorsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAuthenticatorsOutcomeCallable listAuthenticatorsCallable(const Model::ListAuthenticatorsRequest& request) const;
+			ListPwnedPasswordsOutcome listPwnedPasswords(const Model::ListPwnedPasswordsRequest &request)const;
+			void listPwnedPasswordsAsync(const Model::ListPwnedPasswordsRequest& request, const ListPwnedPasswordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListPwnedPasswordsOutcomeCallable listPwnedPasswordsCallable(const Model::ListPwnedPasswordsRequest& request) const;
+			ListUsersOutcome listUsers(const Model::ListUsersRequest &request)const;
+			void listUsersAsync(const Model::ListUsersRequest& request, const ListUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListUsersOutcomeCallable listUsersCallable(const Model::ListUsersRequest& request) const;
+			RegisterAuthenticatorOutcome registerAuthenticator(const Model::RegisterAuthenticatorRequest &request)const;
+			void registerAuthenticatorAsync(const Model::RegisterAuthenticatorRequest& request, const RegisterAuthenticatorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RegisterAuthenticatorOutcomeCallable registerAuthenticatorCallable(const Model::RegisterAuthenticatorRequest& request) const;
+			ServiceInvokeOutcome serviceInvoke(const Model::ServiceInvokeRequest &request)const;
+			void serviceInvokeAsync(const Model::ServiceInvokeRequest& request, const ServiceInvokeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ServiceInvokeOutcomeCallable serviceInvokeCallable(const Model::ServiceInvokeRequest& request) const;
+			UpdateAuthenticatorAttributeOutcome updateAuthenticatorAttribute(const Model::UpdateAuthenticatorAttributeRequest &request)const;
+			void updateAuthenticatorAttributeAsync(const Model::UpdateAuthenticatorAttributeRequest& request, const UpdateAuthenticatorAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateAuthenticatorAttributeOutcomeCallable updateAuthenticatorAttributeCallable(const Model::UpdateAuthenticatorAttributeRequest& request) const;
+			VerifyIdTokenOutcome verifyIdToken(const Model::VerifyIdTokenRequest &request)const;
+			void verifyIdTokenAsync(const Model::VerifyIdTokenRequest& request, const VerifyIdTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VerifyIdTokenOutcomeCallable verifyIdTokenCallable(const Model::VerifyIdTokenRequest& request) const;
+			VerifyUserAuthenticationOutcome verifyUserAuthentication(const Model::VerifyUserAuthenticationRequest &request)const;
+			void verifyUserAuthenticationAsync(const Model::VerifyUserAuthenticationRequest& request, const VerifyUserAuthenticationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			VerifyUserAuthenticationOutcomeCallable verifyUserAuthenticationCallable(const Model::VerifyUserAuthenticationRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_IDAAS_DORAEMONCLIENT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/Idaas_doraemonExport.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_IDAAS_DORAEMON_IDAAS_DORAEMONEXPORT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_IDAAS_DORAEMONEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_IDAAS_DORAEMON_LIBRARY)
+#		define ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_IDAAS_DORAEMON_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_IDAAS_DORAEMONEXPORT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationRequest.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_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT CreateAuthenticatorRegistrationRequest : public RpcServiceRequest {
+public:
+	CreateAuthenticatorRegistrationRequest();
+	~CreateAuthenticatorRegistrationRequest();
+	std::string getClientExtendParamsJson() const;
+	void setClientExtendParamsJson(const std::string &clientExtendParamsJson);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getUserDisplayName() const;
+	void setUserDisplayName(const std::string &userDisplayName);
+	std::string getServerExtendParamsJson() const;
+	void setServerExtendParamsJson(const std::string &serverExtendParamsJson);
+	std::string getRegistrationContext() const;
+	void setRegistrationContext(const std::string &registrationContext);
+	std::string getAuthenticatorType() const;
+	void setAuthenticatorType(const std::string &authenticatorType);
+	std::string getClientExtendParamsJsonSign() const;
+	void setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+	std::string getUserName() const;
+	void setUserName(const std::string &userName);
+
+private:
+	std::string clientExtendParamsJson_;
+	std::string userId_;
+	std::string userDisplayName_;
+	std::string serverExtendParamsJson_;
+	std::string registrationContext_;
+	std::string authenticatorType_;
+	std::string clientExtendParamsJsonSign_;
+	std::string applicationExternalId_;
+	std::string userName_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateAuthenticatorRegistrationResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT CreateAuthenticatorRegistrationResult : public ServiceResult
+			{
+			public:
+
+
+				CreateAuthenticatorRegistrationResult();
+				explicit CreateAuthenticatorRegistrationResult(const std::string &payload);
+				~CreateAuthenticatorRegistrationResult();
+				std::string getOptions()const;
+				std::string getChallengeBase64()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string options_;
+				std::string challengeBase64_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEAUTHENTICATORREGISTRATIONRESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsRequest.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_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT CreateUserAuthenticateOptionsRequest : public RpcServiceRequest {
+public:
+	CreateUserAuthenticateOptionsRequest();
+	~CreateUserAuthenticateOptionsRequest();
+	std::string getClientExtendParamsJson() const;
+	void setClientExtendParamsJson(const std::string &clientExtendParamsJson);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getBindHashBase64() const;
+	void setBindHashBase64(const std::string &bindHashBase64);
+	std::string getServerExtendParamsJson() const;
+	void setServerExtendParamsJson(const std::string &serverExtendParamsJson);
+	std::string getAuthenticatorType() const;
+	void setAuthenticatorType(const std::string &authenticatorType);
+	std::string getClientExtendParamsJsonSign() const;
+	void setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	std::string clientExtendParamsJson_;
+	std::string userId_;
+	std::string bindHashBase64_;
+	std::string serverExtendParamsJson_;
+	std::string authenticatorType_;
+	std::string clientExtendParamsJsonSign_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT CreateUserAuthenticateOptionsResult : public ServiceResult
+			{
+			public:
+
+
+				CreateUserAuthenticateOptionsResult();
+				explicit CreateUserAuthenticateOptionsResult(const std::string &payload);
+				~CreateUserAuthenticateOptionsResult();
+				std::string getOptions()const;
+				std::string getChallengeBase64()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string options_;
+				std::string challengeBase64_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_CREATEUSERAUTHENTICATEOPTIONSRESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorRequest.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_IDAAS_DORAEMON_MODEL_DEREGISTERAUTHENTICATORREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_DEREGISTERAUTHENTICATORREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT DeregisterAuthenticatorRequest : public RpcServiceRequest {
+public:
+	DeregisterAuthenticatorRequest();
+	~DeregisterAuthenticatorRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getAuthenticatorUuid() const;
+	void setAuthenticatorUuid(const std::string &authenticatorUuid);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	std::string userId_;
+	std::string authenticatorUuid_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_DEREGISTERAUTHENTICATORREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/DeregisterAuthenticatorResult.h

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

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/FetchAccessTokenRequest.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_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT FetchAccessTokenRequest : public RpcServiceRequest {
+public:
+	FetchAccessTokenRequest();
+	~FetchAccessTokenRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getXClientIp() const;
+	void setXClientIp(const std::string &xClientIp);
+	std::string getMobileExtendParamsJsonSign() const;
+	void setMobileExtendParamsJsonSign(const std::string &mobileExtendParamsJsonSign);
+	std::string getServerExtendParamsJson() const;
+	void setServerExtendParamsJson(const std::string &serverExtendParamsJson);
+	std::string getMobileExtendParamsJson() const;
+	void setMobileExtendParamsJson(const std::string &mobileExtendParamsJson);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	std::string userId_;
+	std::string xClientIp_;
+	std::string mobileExtendParamsJsonSign_;
+	std::string serverExtendParamsJson_;
+	std::string mobileExtendParamsJson_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/FetchAccessTokenResult.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_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT FetchAccessTokenResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string refresh_token;
+					std::string scope;
+					std::string access_token;
+					std::string id_token;
+					std::string token_type;
+					std::string expires_in;
+				};
+
+
+				FetchAccessTokenResult();
+				explicit FetchAccessTokenResult(const std::string &payload);
+				~FetchAccessTokenResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_FETCHACCESSTOKENRESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/GetAuthenticatorRequest.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_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT GetAuthenticatorRequest : public RpcServiceRequest {
+public:
+	GetAuthenticatorRequest();
+	~GetAuthenticatorRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getAuthenticatorUuid() const;
+	void setAuthenticatorUuid(const std::string &authenticatorUuid);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	std::string userId_;
+	std::string authenticatorUuid_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/GetAuthenticatorResult.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT GetAuthenticatorResult : public ServiceResult
+			{
+			public:
+				struct Authenticator
+				{
+					long registerTime;
+					std::string type;
+					std::string authenticatorUuid;
+					std::string registerSourceIp;
+					std::string credentialId;
+					long lastVerifyTime;
+					std::string authenticatorName;
+					std::string lastVerifySourceIp;
+					std::string customAuthenticator;
+					std::string lastVerifyUserAgent;
+				};
+
+
+				GetAuthenticatorResult();
+				explicit GetAuthenticatorResult(const std::string &payload);
+				~GetAuthenticatorResult();
+				Authenticator getAuthenticator()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Authenticator authenticator_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_GETAUTHENTICATORRESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticationLogsRequest : public RpcServiceRequest {
+public:
+	ListAuthenticationLogsRequest();
+	~ListAuthenticationLogsRequest();
+	long getToTime() const;
+	void setToTime(long toTime);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getLogTag() const;
+	void setLogTag(const std::string &logTag);
+	long getPageNumber() const;
+	void setPageNumber(long pageNumber);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	std::string getCredentialId() const;
+	void setCredentialId(const std::string &credentialId);
+	long getFromTime() const;
+	void setFromTime(long fromTime);
+	std::string getAuthenticatorUuid() const;
+	void setAuthenticatorUuid(const std::string &authenticatorUuid);
+	std::string getAuthenticatorType() const;
+	void setAuthenticatorType(const std::string &authenticatorType);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	long toTime_;
+	std::string userId_;
+	std::string logTag_;
+	long pageNumber_;
+	long pageSize_;
+	std::string credentialId_;
+	long fromTime_;
+	std::string authenticatorUuid_;
+	std::string authenticatorType_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticationLogsResult.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticationLogsResult : public ServiceResult
+			{
+			public:
+				struct AuthenticationLogContentItem
+				{
+					std::string authenticatorType;
+					std::string authenticatorUuid;
+					std::string credentialId;
+					std::string challengeBase64;
+					std::string rawAuthenticationContext;
+					long authenticationTime;
+					std::string applicationExternalId;
+					std::string logTag;
+					std::string logParams;
+					std::string applicationUuid;
+					std::string userSourceIp;
+					std::string tenantId;
+					std::string authenticationAction;
+					std::string userId;
+					std::string authenticatorName;
+					std::string userAgent;
+					std::string errorCode;
+					bool verifyResult;
+					std::string errorMessage;
+					std::string aliUid;
+				};
+
+
+				ListAuthenticationLogsResult();
+				explicit ListAuthenticationLogsResult(const std::string &payload);
+				~ListAuthenticationLogsResult();
+				long getTotalCount()const;
+				std::vector<AuthenticationLogContentItem> getAuthenticationLogContent()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::vector<AuthenticationLogContentItem> authenticationLogContent_;
+				long pageSize_;
+				long pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATIONLOGSRESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsRequest.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_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticatorOpsLogsRequest : public RpcServiceRequest {
+public:
+	ListAuthenticatorOpsLogsRequest();
+	~ListAuthenticatorOpsLogsRequest();
+	long getToTime() const;
+	void setToTime(long toTime);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	long getPageNumber() const;
+	void setPageNumber(long pageNumber);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	long getFromTime() const;
+	void setFromTime(long fromTime);
+	std::string getAuthenticatorUuid() const;
+	void setAuthenticatorUuid(const std::string &authenticatorUuid);
+	std::string getAuthenticatorType() const;
+	void setAuthenticatorType(const std::string &authenticatorType);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	long toTime_;
+	std::string userId_;
+	long pageNumber_;
+	long pageSize_;
+	long fromTime_;
+	std::string authenticatorUuid_;
+	std::string authenticatorType_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorOpsLogsResult.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_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticatorOpsLogsResult : public ServiceResult
+			{
+			public:
+				struct AuthenticationLogContentItem
+				{
+					std::string authenticatorType;
+					std::string authenticatorUuid;
+					std::string credentialId;
+					std::string challengeBase64;
+					std::string rawContext;
+					std::string applicationExternalId;
+					bool operationResult;
+					std::string operationAction;
+					long operationTime;
+					std::string logParams;
+					std::string applicationUuid;
+					std::string userSourceIp;
+					std::string tenantId;
+					std::string userId;
+					std::string authenticatorName;
+					std::string userAgent;
+					std::string errorCode;
+					std::string errorMessage;
+					std::string aliUid;
+				};
+
+
+				ListAuthenticatorOpsLogsResult();
+				explicit ListAuthenticatorOpsLogsResult(const std::string &payload);
+				~ListAuthenticatorOpsLogsResult();
+				long getTotalCount()const;
+				std::vector<AuthenticationLogContentItem> getAuthenticationLogContent()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::vector<AuthenticationLogContentItem> authenticationLogContent_;
+				long pageSize_;
+				long pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATOROPSLOGSRESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsRequest.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_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticatorsRequest : public RpcServiceRequest {
+public:
+	ListAuthenticatorsRequest();
+	~ListAuthenticatorsRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	long getPageNumber() const;
+	void setPageNumber(long pageNumber);
+	long getPageSize() const;
+	void setPageSize(long pageSize);
+	std::string getAuthenticatorType() const;
+	void setAuthenticatorType(const std::string &authenticatorType);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	std::string userId_;
+	long pageNumber_;
+	long pageSize_;
+	std::string authenticatorType_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListAuthenticatorsResult.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListAuthenticatorsResult : public ServiceResult
+			{
+			public:
+				struct AuthenticatorListDTO
+				{
+					long registerTime;
+					std::string type;
+					std::string authenticatorUuid;
+					std::string credentialId;
+					long lastVerifyTime;
+					std::string authenticatorName;
+					std::string applicationExternalId;
+				};
+
+
+				ListAuthenticatorsResult();
+				explicit ListAuthenticatorsResult(const std::string &payload);
+				~ListAuthenticatorsResult();
+				long getTotalCount()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+				std::vector<AuthenticatorListDTO> getAuthenticator()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				long pageSize_;
+				long pageNumber_;
+				std::vector<AuthenticatorListDTO> authenticator_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTAUTHENTICATORSRESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsRequest.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_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListPwnedPasswordsRequest : public RpcServiceRequest {
+public:
+	ListPwnedPasswordsRequest();
+	~ListPwnedPasswordsRequest();
+	std::string getPrefixHexPasswordSha1Hash() const;
+	void setPrefixHexPasswordSha1Hash(const std::string &prefixHexPasswordSha1Hash);
+
+private:
+	std::string prefixHexPasswordSha1Hash_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListPwnedPasswordsResult.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_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListPwnedPasswordsResult : public ServiceResult
+			{
+			public:
+				struct Items
+				{
+					std::string hexPasswordSha1Hash;
+					long pwnedCount;
+				};
+
+
+				ListPwnedPasswordsResult();
+				explicit ListPwnedPasswordsResult(const std::string &payload);
+				~ListPwnedPasswordsResult();
+				long getTotalCount()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+				std::vector<Items> getPwnedPasswordInfos()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				long pageSize_;
+				long pageNumber_;
+				std::vector<Items> pwnedPasswordInfos_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTPWNEDPASSWORDSRESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListUsersRequest.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_IDAAS_DORAEMON_MODEL_LISTUSERSREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTUSERSREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListUsersRequest : public RpcServiceRequest {
+public:
+	ListUsersRequest();
+	~ListUsersRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	std::string userId_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTUSERSREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ListUsersResult.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_IDAAS_DORAEMON_MODEL_LISTUSERSRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTUSERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ListUsersResult : public ServiceResult
+			{
+			public:
+				struct UsersItem
+				{
+					std::string userName;
+					std::string userId;
+					std::string userDisplayName;
+				};
+
+
+				ListUsersResult();
+				explicit ListUsersResult(const std::string &payload);
+				~ListUsersResult();
+				long getTotalCount()const;
+				std::vector<UsersItem> getUsers()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::vector<UsersItem> users_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_LISTUSERSRESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT RegisterAuthenticatorRequest : public RpcServiceRequest {
+public:
+	RegisterAuthenticatorRequest();
+	~RegisterAuthenticatorRequest();
+	std::string getLogParams() const;
+	void setLogParams(const std::string &logParams);
+	std::string getClientExtendParamsJson() const;
+	void setClientExtendParamsJson(const std::string &clientExtendParamsJson);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getServerExtendParamsJson() const;
+	void setServerExtendParamsJson(const std::string &serverExtendParamsJson);
+	std::string getRegistrationContext() const;
+	void setRegistrationContext(const std::string &registrationContext);
+	std::string getAuthenticatorName() const;
+	void setAuthenticatorName(const std::string &authenticatorName);
+	std::string getRequireChallengeBase64() const;
+	void setRequireChallengeBase64(const std::string &requireChallengeBase64);
+	std::string getAuthenticatorType() const;
+	void setAuthenticatorType(const std::string &authenticatorType);
+	std::string getClientExtendParamsJsonSign() const;
+	void setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign);
+	std::string getUserSourceIp() const;
+	void setUserSourceIp(const std::string &userSourceIp);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	std::string logParams_;
+	std::string clientExtendParamsJson_;
+	std::string userId_;
+	std::string serverExtendParamsJson_;
+	std::string registrationContext_;
+	std::string authenticatorName_;
+	std::string requireChallengeBase64_;
+	std::string authenticatorType_;
+	std::string clientExtendParamsJsonSign_;
+	std::string userSourceIp_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/RegisterAuthenticatorResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT RegisterAuthenticatorResult : public ServiceResult
+			{
+			public:
+
+
+				RegisterAuthenticatorResult();
+				explicit RegisterAuthenticatorResult(const std::string &payload);
+				~RegisterAuthenticatorResult();
+				std::string getEtasResponseSting()const;
+				std::string getAuthenticatorUuid()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string etasResponseSting_;
+				std::string authenticatorUuid_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_REGISTERAUTHENTICATORRESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ServiceInvokeRequest.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_IDAAS_DORAEMON_MODEL_SERVICEINVOKEREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_SERVICEINVOKEREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ServiceInvokeRequest : public RpcServiceRequest {
+public:
+	ServiceInvokeRequest();
+	~ServiceInvokeRequest();
+	std::string getXClientIp() const;
+	void setXClientIp(const std::string &xClientIp);
+	std::string getMobileExtendParamsJsonSign() const;
+	void setMobileExtendParamsJsonSign(const std::string &mobileExtendParamsJsonSign);
+	std::string getServerExtendParamsJson() const;
+	void setServerExtendParamsJson(const std::string &serverExtendParamsJson);
+	std::string getDoraemonAction() const;
+	void setDoraemonAction(const std::string &doraemonAction);
+	std::string getMobileExtendParamsJson() const;
+	void setMobileExtendParamsJson(const std::string &mobileExtendParamsJson);
+	std::string getServiceCode() const;
+	void setServiceCode(const std::string &serviceCode);
+	bool getTestModel() const;
+	void setTestModel(bool testModel);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	std::string xClientIp_;
+	std::string mobileExtendParamsJsonSign_;
+	std::string serverExtendParamsJson_;
+	std::string doraemonAction_;
+	std::string mobileExtendParamsJson_;
+	std::string serviceCode_;
+	bool testModel_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_SERVICEINVOKEREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/ServiceInvokeResult.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_IDAAS_DORAEMON_MODEL_SERVICEINVOKERESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_SERVICEINVOKERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT ServiceInvokeResult : public ServiceResult
+			{
+			public:
+
+
+				ServiceInvokeResult();
+				explicit ServiceInvokeResult(const std::string &payload);
+				~ServiceInvokeResult();
+				std::string getIdToken()const;
+				std::string getMessage()const;
+				std::string getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string idToken_;
+				std::string message_;
+				std::string data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_SERVICEINVOKERESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeRequest.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_IDAAS_DORAEMON_MODEL_UPDATEAUTHENTICATORATTRIBUTEREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_UPDATEAUTHENTICATORATTRIBUTEREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT UpdateAuthenticatorAttributeRequest : public RpcServiceRequest {
+public:
+	UpdateAuthenticatorAttributeRequest();
+	~UpdateAuthenticatorAttributeRequest();
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getAuthenticatorName() const;
+	void setAuthenticatorName(const std::string &authenticatorName);
+	std::string getAuthenticatorUuid() const;
+	void setAuthenticatorUuid(const std::string &authenticatorUuid);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	std::string userId_;
+	std::string authenticatorName_;
+	std::string authenticatorUuid_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_UPDATEAUTHENTICATORATTRIBUTEREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/UpdateAuthenticatorAttributeResult.h

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

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyIdTokenRequest.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_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT VerifyIdTokenRequest : public RpcServiceRequest {
+public:
+	VerifyIdTokenRequest();
+	~VerifyIdTokenRequest();
+	std::string getJwtIdToken() const;
+	void setJwtIdToken(const std::string &jwtIdToken);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	std::string jwtIdToken_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyIdTokenResult.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_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT VerifyIdTokenResult : public ServiceResult
+			{
+			public:
+
+
+				VerifyIdTokenResult();
+				explicit VerifyIdTokenResult(const std::string &payload);
+				~VerifyIdTokenResult();
+				std::string getUserId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string userId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYIDTOKENRESULT_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONREQUEST_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONREQUEST_H_
+
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Idaas_doraemon {
+namespace Model {
+class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT VerifyUserAuthenticationRequest : public RpcServiceRequest {
+public:
+	VerifyUserAuthenticationRequest();
+	~VerifyUserAuthenticationRequest();
+	std::string getLogParams() const;
+	void setLogParams(const std::string &logParams);
+	std::string getClientExtendParamsJson() const;
+	void setClientExtendParamsJson(const std::string &clientExtendParamsJson);
+	std::string getUserId() const;
+	void setUserId(const std::string &userId);
+	std::string getLogTag() const;
+	void setLogTag(const std::string &logTag);
+	std::string getServerExtendParamsJson() const;
+	void setServerExtendParamsJson(const std::string &serverExtendParamsJson);
+	std::string getRequireBindHashBase64() const;
+	void setRequireBindHashBase64(const std::string &requireBindHashBase64);
+	std::string getAuthenticationContext() const;
+	void setAuthenticationContext(const std::string &authenticationContext);
+	std::string getRequireChallengeBase64() const;
+	void setRequireChallengeBase64(const std::string &requireChallengeBase64);
+	std::string getAuthenticatorType() const;
+	void setAuthenticatorType(const std::string &authenticatorType);
+	std::string getClientExtendParamsJsonSign() const;
+	void setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign);
+	std::string getUserSourceIp() const;
+	void setUserSourceIp(const std::string &userSourceIp);
+	std::string getApplicationExternalId() const;
+	void setApplicationExternalId(const std::string &applicationExternalId);
+
+private:
+	std::string logParams_;
+	std::string clientExtendParamsJson_;
+	std::string userId_;
+	std::string logTag_;
+	std::string serverExtendParamsJson_;
+	std::string requireBindHashBase64_;
+	std::string authenticationContext_;
+	std::string requireChallengeBase64_;
+	std::string authenticatorType_;
+	std::string clientExtendParamsJsonSign_;
+	std::string userSourceIp_;
+	std::string applicationExternalId_;
+};
+} // namespace Model
+} // namespace Idaas_doraemon
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONREQUEST_H_

idaas-doraemon/include/alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationResult.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_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONRESULT_H_
+#define ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/idaas-doraemon/Idaas_doraemonExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Idaas_doraemon
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IDAAS_DORAEMON_EXPORT VerifyUserAuthenticationResult : public ServiceResult
+			{
+			public:
+				struct AuthenticateResultInfo
+				{
+					std::string bindHashBase64;
+					std::string credentialId;
+					std::string userId;
+				};
+
+
+				VerifyUserAuthenticationResult();
+				explicit VerifyUserAuthenticationResult(const std::string &payload);
+				~VerifyUserAuthenticationResult();
+				std::string getIdToken()const;
+				AuthenticateResultInfo getAuthenticateResultInfo()const;
+				std::string getEtasSDKString()const;
+				bool getVerifyResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string idToken_;
+				AuthenticateResultInfo authenticateResultInfo_;
+				std::string etasSDKString_;
+				bool verifyResult_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IDAAS_DORAEMON_MODEL_VERIFYUSERAUTHENTICATIONRESULT_H_

idaas-doraemon/src/Idaas-doraemonClient.cc

@@ -0,0 +1,593 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/idaas-doraemon/Idaas_doraemonClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "idaas-doraemon";
+}
+
+Idaas_doraemonClient::Idaas_doraemonClient(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, "");
+}
+
+Idaas_doraemonClient::Idaas_doraemonClient(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, "");
+}
+
+Idaas_doraemonClient::Idaas_doraemonClient(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, "");
+}
+
+Idaas_doraemonClient::~Idaas_doraemonClient()
+{}
+
+Idaas_doraemonClient::CreateAuthenticatorRegistrationOutcome Idaas_doraemonClient::createAuthenticatorRegistration(const CreateAuthenticatorRegistrationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateAuthenticatorRegistrationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateAuthenticatorRegistrationOutcome(CreateAuthenticatorRegistrationResult(outcome.result()));
+	else
+		return CreateAuthenticatorRegistrationOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::createAuthenticatorRegistrationAsync(const CreateAuthenticatorRegistrationRequest& request, const CreateAuthenticatorRegistrationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createAuthenticatorRegistration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::CreateAuthenticatorRegistrationOutcomeCallable Idaas_doraemonClient::createAuthenticatorRegistrationCallable(const CreateAuthenticatorRegistrationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateAuthenticatorRegistrationOutcome()>>(
+			[this, request]()
+			{
+			return this->createAuthenticatorRegistration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::CreateUserAuthenticateOptionsOutcome Idaas_doraemonClient::createUserAuthenticateOptions(const CreateUserAuthenticateOptionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateUserAuthenticateOptionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateUserAuthenticateOptionsOutcome(CreateUserAuthenticateOptionsResult(outcome.result()));
+	else
+		return CreateUserAuthenticateOptionsOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::createUserAuthenticateOptionsAsync(const CreateUserAuthenticateOptionsRequest& request, const CreateUserAuthenticateOptionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createUserAuthenticateOptions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::CreateUserAuthenticateOptionsOutcomeCallable Idaas_doraemonClient::createUserAuthenticateOptionsCallable(const CreateUserAuthenticateOptionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateUserAuthenticateOptionsOutcome()>>(
+			[this, request]()
+			{
+			return this->createUserAuthenticateOptions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::DeregisterAuthenticatorOutcome Idaas_doraemonClient::deregisterAuthenticator(const DeregisterAuthenticatorRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeregisterAuthenticatorOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeregisterAuthenticatorOutcome(DeregisterAuthenticatorResult(outcome.result()));
+	else
+		return DeregisterAuthenticatorOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::deregisterAuthenticatorAsync(const DeregisterAuthenticatorRequest& request, const DeregisterAuthenticatorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deregisterAuthenticator(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::DeregisterAuthenticatorOutcomeCallable Idaas_doraemonClient::deregisterAuthenticatorCallable(const DeregisterAuthenticatorRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeregisterAuthenticatorOutcome()>>(
+			[this, request]()
+			{
+			return this->deregisterAuthenticator(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::FetchAccessTokenOutcome Idaas_doraemonClient::fetchAccessToken(const FetchAccessTokenRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return FetchAccessTokenOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return FetchAccessTokenOutcome(FetchAccessTokenResult(outcome.result()));
+	else
+		return FetchAccessTokenOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::fetchAccessTokenAsync(const FetchAccessTokenRequest& request, const FetchAccessTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, fetchAccessToken(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::FetchAccessTokenOutcomeCallable Idaas_doraemonClient::fetchAccessTokenCallable(const FetchAccessTokenRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<FetchAccessTokenOutcome()>>(
+			[this, request]()
+			{
+			return this->fetchAccessToken(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::GetAuthenticatorOutcome Idaas_doraemonClient::getAuthenticator(const GetAuthenticatorRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAuthenticatorOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAuthenticatorOutcome(GetAuthenticatorResult(outcome.result()));
+	else
+		return GetAuthenticatorOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::getAuthenticatorAsync(const GetAuthenticatorRequest& request, const GetAuthenticatorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAuthenticator(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::GetAuthenticatorOutcomeCallable Idaas_doraemonClient::getAuthenticatorCallable(const GetAuthenticatorRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAuthenticatorOutcome()>>(
+			[this, request]()
+			{
+			return this->getAuthenticator(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::ListAuthenticationLogsOutcome Idaas_doraemonClient::listAuthenticationLogs(const ListAuthenticationLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListAuthenticationLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListAuthenticationLogsOutcome(ListAuthenticationLogsResult(outcome.result()));
+	else
+		return ListAuthenticationLogsOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::listAuthenticationLogsAsync(const ListAuthenticationLogsRequest& request, const ListAuthenticationLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listAuthenticationLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::ListAuthenticationLogsOutcomeCallable Idaas_doraemonClient::listAuthenticationLogsCallable(const ListAuthenticationLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListAuthenticationLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->listAuthenticationLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::ListAuthenticatorOpsLogsOutcome Idaas_doraemonClient::listAuthenticatorOpsLogs(const ListAuthenticatorOpsLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListAuthenticatorOpsLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListAuthenticatorOpsLogsOutcome(ListAuthenticatorOpsLogsResult(outcome.result()));
+	else
+		return ListAuthenticatorOpsLogsOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::listAuthenticatorOpsLogsAsync(const ListAuthenticatorOpsLogsRequest& request, const ListAuthenticatorOpsLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listAuthenticatorOpsLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::ListAuthenticatorOpsLogsOutcomeCallable Idaas_doraemonClient::listAuthenticatorOpsLogsCallable(const ListAuthenticatorOpsLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListAuthenticatorOpsLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->listAuthenticatorOpsLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::ListAuthenticatorsOutcome Idaas_doraemonClient::listAuthenticators(const ListAuthenticatorsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListAuthenticatorsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListAuthenticatorsOutcome(ListAuthenticatorsResult(outcome.result()));
+	else
+		return ListAuthenticatorsOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::listAuthenticatorsAsync(const ListAuthenticatorsRequest& request, const ListAuthenticatorsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listAuthenticators(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::ListAuthenticatorsOutcomeCallable Idaas_doraemonClient::listAuthenticatorsCallable(const ListAuthenticatorsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListAuthenticatorsOutcome()>>(
+			[this, request]()
+			{
+			return this->listAuthenticators(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::ListPwnedPasswordsOutcome Idaas_doraemonClient::listPwnedPasswords(const ListPwnedPasswordsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListPwnedPasswordsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListPwnedPasswordsOutcome(ListPwnedPasswordsResult(outcome.result()));
+	else
+		return ListPwnedPasswordsOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::listPwnedPasswordsAsync(const ListPwnedPasswordsRequest& request, const ListPwnedPasswordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listPwnedPasswords(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::ListPwnedPasswordsOutcomeCallable Idaas_doraemonClient::listPwnedPasswordsCallable(const ListPwnedPasswordsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListPwnedPasswordsOutcome()>>(
+			[this, request]()
+			{
+			return this->listPwnedPasswords(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::ListUsersOutcome Idaas_doraemonClient::listUsers(const ListUsersRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListUsersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListUsersOutcome(ListUsersResult(outcome.result()));
+	else
+		return ListUsersOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::listUsersAsync(const ListUsersRequest& request, const ListUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listUsers(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::ListUsersOutcomeCallable Idaas_doraemonClient::listUsersCallable(const ListUsersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListUsersOutcome()>>(
+			[this, request]()
+			{
+			return this->listUsers(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::RegisterAuthenticatorOutcome Idaas_doraemonClient::registerAuthenticator(const RegisterAuthenticatorRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RegisterAuthenticatorOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RegisterAuthenticatorOutcome(RegisterAuthenticatorResult(outcome.result()));
+	else
+		return RegisterAuthenticatorOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::registerAuthenticatorAsync(const RegisterAuthenticatorRequest& request, const RegisterAuthenticatorAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, registerAuthenticator(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::RegisterAuthenticatorOutcomeCallable Idaas_doraemonClient::registerAuthenticatorCallable(const RegisterAuthenticatorRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RegisterAuthenticatorOutcome()>>(
+			[this, request]()
+			{
+			return this->registerAuthenticator(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::ServiceInvokeOutcome Idaas_doraemonClient::serviceInvoke(const ServiceInvokeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ServiceInvokeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ServiceInvokeOutcome(ServiceInvokeResult(outcome.result()));
+	else
+		return ServiceInvokeOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::serviceInvokeAsync(const ServiceInvokeRequest& request, const ServiceInvokeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, serviceInvoke(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::ServiceInvokeOutcomeCallable Idaas_doraemonClient::serviceInvokeCallable(const ServiceInvokeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ServiceInvokeOutcome()>>(
+			[this, request]()
+			{
+			return this->serviceInvoke(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::UpdateAuthenticatorAttributeOutcome Idaas_doraemonClient::updateAuthenticatorAttribute(const UpdateAuthenticatorAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateAuthenticatorAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateAuthenticatorAttributeOutcome(UpdateAuthenticatorAttributeResult(outcome.result()));
+	else
+		return UpdateAuthenticatorAttributeOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::updateAuthenticatorAttributeAsync(const UpdateAuthenticatorAttributeRequest& request, const UpdateAuthenticatorAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateAuthenticatorAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::UpdateAuthenticatorAttributeOutcomeCallable Idaas_doraemonClient::updateAuthenticatorAttributeCallable(const UpdateAuthenticatorAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateAuthenticatorAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->updateAuthenticatorAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::VerifyIdTokenOutcome Idaas_doraemonClient::verifyIdToken(const VerifyIdTokenRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VerifyIdTokenOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VerifyIdTokenOutcome(VerifyIdTokenResult(outcome.result()));
+	else
+		return VerifyIdTokenOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::verifyIdTokenAsync(const VerifyIdTokenRequest& request, const VerifyIdTokenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, verifyIdToken(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::VerifyIdTokenOutcomeCallable Idaas_doraemonClient::verifyIdTokenCallable(const VerifyIdTokenRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VerifyIdTokenOutcome()>>(
+			[this, request]()
+			{
+			return this->verifyIdToken(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Idaas_doraemonClient::VerifyUserAuthenticationOutcome Idaas_doraemonClient::verifyUserAuthentication(const VerifyUserAuthenticationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return VerifyUserAuthenticationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return VerifyUserAuthenticationOutcome(VerifyUserAuthenticationResult(outcome.result()));
+	else
+		return VerifyUserAuthenticationOutcome(outcome.error());
+}
+
+void Idaas_doraemonClient::verifyUserAuthenticationAsync(const VerifyUserAuthenticationRequest& request, const VerifyUserAuthenticationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, verifyUserAuthentication(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Idaas_doraemonClient::VerifyUserAuthenticationOutcomeCallable Idaas_doraemonClient::verifyUserAuthenticationCallable(const VerifyUserAuthenticationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<VerifyUserAuthenticationOutcome()>>(
+			[this, request]()
+			{
+			return this->verifyUserAuthentication(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

idaas-doraemon/src/model/CreateAuthenticatorRegistrationRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/idaas-doraemon/model/CreateAuthenticatorRegistrationRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::CreateAuthenticatorRegistrationRequest;
+
+CreateAuthenticatorRegistrationRequest::CreateAuthenticatorRegistrationRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "CreateAuthenticatorRegistration") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateAuthenticatorRegistrationRequest::~CreateAuthenticatorRegistrationRequest() {}
+
+std::string CreateAuthenticatorRegistrationRequest::getClientExtendParamsJson() const {
+  return clientExtendParamsJson_;
+}
+
+void CreateAuthenticatorRegistrationRequest::setClientExtendParamsJson(const std::string &clientExtendParamsJson) {
+  clientExtendParamsJson_ = clientExtendParamsJson;
+  setParameter(std::string("ClientExtendParamsJson"), clientExtendParamsJson);
+}
+
+std::string CreateAuthenticatorRegistrationRequest::getUserId() const {
+  return userId_;
+}
+
+void CreateAuthenticatorRegistrationRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string CreateAuthenticatorRegistrationRequest::getUserDisplayName() const {
+  return userDisplayName_;
+}
+
+void CreateAuthenticatorRegistrationRequest::setUserDisplayName(const std::string &userDisplayName) {
+  userDisplayName_ = userDisplayName;
+  setParameter(std::string("UserDisplayName"), userDisplayName);
+}
+
+std::string CreateAuthenticatorRegistrationRequest::getServerExtendParamsJson() const {
+  return serverExtendParamsJson_;
+}
+
+void CreateAuthenticatorRegistrationRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) {
+  serverExtendParamsJson_ = serverExtendParamsJson;
+  setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson);
+}
+
+std::string CreateAuthenticatorRegistrationRequest::getRegistrationContext() const {
+  return registrationContext_;
+}
+
+void CreateAuthenticatorRegistrationRequest::setRegistrationContext(const std::string &registrationContext) {
+  registrationContext_ = registrationContext;
+  setParameter(std::string("RegistrationContext"), registrationContext);
+}
+
+std::string CreateAuthenticatorRegistrationRequest::getAuthenticatorType() const {
+  return authenticatorType_;
+}
+
+void CreateAuthenticatorRegistrationRequest::setAuthenticatorType(const std::string &authenticatorType) {
+  authenticatorType_ = authenticatorType;
+  setParameter(std::string("AuthenticatorType"), authenticatorType);
+}
+
+std::string CreateAuthenticatorRegistrationRequest::getClientExtendParamsJsonSign() const {
+  return clientExtendParamsJsonSign_;
+}
+
+void CreateAuthenticatorRegistrationRequest::setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign) {
+  clientExtendParamsJsonSign_ = clientExtendParamsJsonSign;
+  setParameter(std::string("ClientExtendParamsJsonSign"), clientExtendParamsJsonSign);
+}
+
+std::string CreateAuthenticatorRegistrationRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void CreateAuthenticatorRegistrationRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+
+std::string CreateAuthenticatorRegistrationRequest::getUserName() const {
+  return userName_;
+}
+
+void CreateAuthenticatorRegistrationRequest::setUserName(const std::string &userName) {
+  userName_ = userName;
+  setParameter(std::string("UserName"), userName);
+}
+

idaas-doraemon/src/model/CreateAuthenticatorRegistrationResult.cc

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/idaas-doraemon/model/CreateAuthenticatorRegistrationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+CreateAuthenticatorRegistrationResult::CreateAuthenticatorRegistrationResult() :
+	ServiceResult()
+{}
+
+CreateAuthenticatorRegistrationResult::CreateAuthenticatorRegistrationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateAuthenticatorRegistrationResult::~CreateAuthenticatorRegistrationResult()
+{}
+
+void CreateAuthenticatorRegistrationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ChallengeBase64"].isNull())
+		challengeBase64_ = value["ChallengeBase64"].asString();
+	if(!value["Options"].isNull())
+		options_ = value["Options"].asString();
+
+}
+
+std::string CreateAuthenticatorRegistrationResult::getOptions()const
+{
+	return options_;
+}
+
+std::string CreateAuthenticatorRegistrationResult::getChallengeBase64()const
+{
+	return challengeBase64_;
+}
+

idaas-doraemon/src/model/CreateUserAuthenticateOptionsRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/idaas-doraemon/model/CreateUserAuthenticateOptionsRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::CreateUserAuthenticateOptionsRequest;
+
+CreateUserAuthenticateOptionsRequest::CreateUserAuthenticateOptionsRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "CreateUserAuthenticateOptions") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateUserAuthenticateOptionsRequest::~CreateUserAuthenticateOptionsRequest() {}
+
+std::string CreateUserAuthenticateOptionsRequest::getClientExtendParamsJson() const {
+  return clientExtendParamsJson_;
+}
+
+void CreateUserAuthenticateOptionsRequest::setClientExtendParamsJson(const std::string &clientExtendParamsJson) {
+  clientExtendParamsJson_ = clientExtendParamsJson;
+  setParameter(std::string("ClientExtendParamsJson"), clientExtendParamsJson);
+}
+
+std::string CreateUserAuthenticateOptionsRequest::getUserId() const {
+  return userId_;
+}
+
+void CreateUserAuthenticateOptionsRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string CreateUserAuthenticateOptionsRequest::getBindHashBase64() const {
+  return bindHashBase64_;
+}
+
+void CreateUserAuthenticateOptionsRequest::setBindHashBase64(const std::string &bindHashBase64) {
+  bindHashBase64_ = bindHashBase64;
+  setParameter(std::string("BindHashBase64"), bindHashBase64);
+}
+
+std::string CreateUserAuthenticateOptionsRequest::getServerExtendParamsJson() const {
+  return serverExtendParamsJson_;
+}
+
+void CreateUserAuthenticateOptionsRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) {
+  serverExtendParamsJson_ = serverExtendParamsJson;
+  setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson);
+}
+
+std::string CreateUserAuthenticateOptionsRequest::getAuthenticatorType() const {
+  return authenticatorType_;
+}
+
+void CreateUserAuthenticateOptionsRequest::setAuthenticatorType(const std::string &authenticatorType) {
+  authenticatorType_ = authenticatorType;
+  setParameter(std::string("AuthenticatorType"), authenticatorType);
+}
+
+std::string CreateUserAuthenticateOptionsRequest::getClientExtendParamsJsonSign() const {
+  return clientExtendParamsJsonSign_;
+}
+
+void CreateUserAuthenticateOptionsRequest::setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign) {
+  clientExtendParamsJsonSign_ = clientExtendParamsJsonSign;
+  setParameter(std::string("ClientExtendParamsJsonSign"), clientExtendParamsJsonSign);
+}
+
+std::string CreateUserAuthenticateOptionsRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void CreateUserAuthenticateOptionsRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/CreateUserAuthenticateOptionsResult.cc

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/idaas-doraemon/model/CreateUserAuthenticateOptionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+CreateUserAuthenticateOptionsResult::CreateUserAuthenticateOptionsResult() :
+	ServiceResult()
+{}
+
+CreateUserAuthenticateOptionsResult::CreateUserAuthenticateOptionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateUserAuthenticateOptionsResult::~CreateUserAuthenticateOptionsResult()
+{}
+
+void CreateUserAuthenticateOptionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ChallengeBase64"].isNull())
+		challengeBase64_ = value["ChallengeBase64"].asString();
+	if(!value["Options"].isNull())
+		options_ = value["Options"].asString();
+
+}
+
+std::string CreateUserAuthenticateOptionsResult::getOptions()const
+{
+	return options_;
+}
+
+std::string CreateUserAuthenticateOptionsResult::getChallengeBase64()const
+{
+	return challengeBase64_;
+}
+

idaas-doraemon/src/model/DeregisterAuthenticatorRequest.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/idaas-doraemon/model/DeregisterAuthenticatorRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::DeregisterAuthenticatorRequest;
+
+DeregisterAuthenticatorRequest::DeregisterAuthenticatorRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "DeregisterAuthenticator") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeregisterAuthenticatorRequest::~DeregisterAuthenticatorRequest() {}
+
+std::string DeregisterAuthenticatorRequest::getUserId() const {
+  return userId_;
+}
+
+void DeregisterAuthenticatorRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string DeregisterAuthenticatorRequest::getAuthenticatorUuid() const {
+  return authenticatorUuid_;
+}
+
+void DeregisterAuthenticatorRequest::setAuthenticatorUuid(const std::string &authenticatorUuid) {
+  authenticatorUuid_ = authenticatorUuid;
+  setParameter(std::string("AuthenticatorUuid"), authenticatorUuid);
+}
+
+std::string DeregisterAuthenticatorRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void DeregisterAuthenticatorRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/DeregisterAuthenticatorResult.cc

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

idaas-doraemon/src/model/FetchAccessTokenRequest.cc

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/idaas-doraemon/model/FetchAccessTokenRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::FetchAccessTokenRequest;
+
+FetchAccessTokenRequest::FetchAccessTokenRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "FetchAccessToken") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+FetchAccessTokenRequest::~FetchAccessTokenRequest() {}
+
+std::string FetchAccessTokenRequest::getUserId() const {
+  return userId_;
+}
+
+void FetchAccessTokenRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string FetchAccessTokenRequest::getXClientIp() const {
+  return xClientIp_;
+}
+
+void FetchAccessTokenRequest::setXClientIp(const std::string &xClientIp) {
+  xClientIp_ = xClientIp;
+  setParameter(std::string("XClientIp"), xClientIp);
+}
+
+std::string FetchAccessTokenRequest::getMobileExtendParamsJsonSign() const {
+  return mobileExtendParamsJsonSign_;
+}
+
+void FetchAccessTokenRequest::setMobileExtendParamsJsonSign(const std::string &mobileExtendParamsJsonSign) {
+  mobileExtendParamsJsonSign_ = mobileExtendParamsJsonSign;
+  setParameter(std::string("MobileExtendParamsJsonSign"), mobileExtendParamsJsonSign);
+}
+
+std::string FetchAccessTokenRequest::getServerExtendParamsJson() const {
+  return serverExtendParamsJson_;
+}
+
+void FetchAccessTokenRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) {
+  serverExtendParamsJson_ = serverExtendParamsJson;
+  setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson);
+}
+
+std::string FetchAccessTokenRequest::getMobileExtendParamsJson() const {
+  return mobileExtendParamsJson_;
+}
+
+void FetchAccessTokenRequest::setMobileExtendParamsJson(const std::string &mobileExtendParamsJson) {
+  mobileExtendParamsJson_ = mobileExtendParamsJson;
+  setParameter(std::string("MobileExtendParamsJson"), mobileExtendParamsJson);
+}
+
+std::string FetchAccessTokenRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void FetchAccessTokenRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/FetchAccessTokenResult.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/idaas-doraemon/model/FetchAccessTokenResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+FetchAccessTokenResult::FetchAccessTokenResult() :
+	ServiceResult()
+{}
+
+FetchAccessTokenResult::FetchAccessTokenResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+FetchAccessTokenResult::~FetchAccessTokenResult()
+{}
+
+void FetchAccessTokenResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Access_token"].isNull())
+		data_.access_token = dataNode["Access_token"].asString();
+	if(!dataNode["Token_type"].isNull())
+		data_.token_type = dataNode["Token_type"].asString();
+	if(!dataNode["Scope"].isNull())
+		data_.scope = dataNode["Scope"].asString();
+	if(!dataNode["Expires_in"].isNull())
+		data_.expires_in = dataNode["Expires_in"].asString();
+	if(!dataNode["Refresh_token"].isNull())
+		data_.refresh_token = dataNode["Refresh_token"].asString();
+	if(!dataNode["Id_token"].isNull())
+		data_.id_token = dataNode["Id_token"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string FetchAccessTokenResult::getMessage()const
+{
+	return message_;
+}
+
+FetchAccessTokenResult::Data FetchAccessTokenResult::getData()const
+{
+	return data_;
+}
+
+std::string FetchAccessTokenResult::getCode()const
+{
+	return code_;
+}
+
+bool FetchAccessTokenResult::getSuccess()const
+{
+	return success_;
+}
+

idaas-doraemon/src/model/GetAuthenticatorRequest.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/idaas-doraemon/model/GetAuthenticatorRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::GetAuthenticatorRequest;
+
+GetAuthenticatorRequest::GetAuthenticatorRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "GetAuthenticator") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetAuthenticatorRequest::~GetAuthenticatorRequest() {}
+
+std::string GetAuthenticatorRequest::getUserId() const {
+  return userId_;
+}
+
+void GetAuthenticatorRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string GetAuthenticatorRequest::getAuthenticatorUuid() const {
+  return authenticatorUuid_;
+}
+
+void GetAuthenticatorRequest::setAuthenticatorUuid(const std::string &authenticatorUuid) {
+  authenticatorUuid_ = authenticatorUuid;
+  setParameter(std::string("AuthenticatorUuid"), authenticatorUuid);
+}
+
+std::string GetAuthenticatorRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void GetAuthenticatorRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/GetAuthenticatorResult.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/idaas-doraemon/model/GetAuthenticatorResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+GetAuthenticatorResult::GetAuthenticatorResult() :
+	ServiceResult()
+{}
+
+GetAuthenticatorResult::GetAuthenticatorResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetAuthenticatorResult::~GetAuthenticatorResult()
+{}
+
+void GetAuthenticatorResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto authenticatorNode = value["Authenticator"];
+	if(!authenticatorNode["AuthenticatorUuid"].isNull())
+		authenticator_.authenticatorUuid = authenticatorNode["AuthenticatorUuid"].asString();
+	if(!authenticatorNode["CredentialId"].isNull())
+		authenticator_.credentialId = authenticatorNode["CredentialId"].asString();
+	if(!authenticatorNode["Type"].isNull())
+		authenticator_.type = authenticatorNode["Type"].asString();
+	if(!authenticatorNode["AuthenticatorName"].isNull())
+		authenticator_.authenticatorName = authenticatorNode["AuthenticatorName"].asString();
+	if(!authenticatorNode["RegisterTime"].isNull())
+		authenticator_.registerTime = std::stol(authenticatorNode["RegisterTime"].asString());
+	if(!authenticatorNode["LastVerifyTime"].isNull())
+		authenticator_.lastVerifyTime = std::stol(authenticatorNode["LastVerifyTime"].asString());
+	if(!authenticatorNode["RegisterSourceIp"].isNull())
+		authenticator_.registerSourceIp = authenticatorNode["RegisterSourceIp"].asString();
+	if(!authenticatorNode["LastVerifySourceIp"].isNull())
+		authenticator_.lastVerifySourceIp = authenticatorNode["LastVerifySourceIp"].asString();
+	if(!authenticatorNode["LastVerifyUserAgent"].isNull())
+		authenticator_.lastVerifyUserAgent = authenticatorNode["LastVerifyUserAgent"].asString();
+	if(!authenticatorNode["CustomAuthenticator"].isNull())
+		authenticator_.customAuthenticator = authenticatorNode["CustomAuthenticator"].asString();
+
+}
+
+GetAuthenticatorResult::Authenticator GetAuthenticatorResult::getAuthenticator()const
+{
+	return authenticator_;
+}
+

idaas-doraemon/src/model/ListAuthenticationLogsRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/idaas-doraemon/model/ListAuthenticationLogsRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::ListAuthenticationLogsRequest;
+
+ListAuthenticationLogsRequest::ListAuthenticationLogsRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ListAuthenticationLogs") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListAuthenticationLogsRequest::~ListAuthenticationLogsRequest() {}
+
+long ListAuthenticationLogsRequest::getToTime() const {
+  return toTime_;
+}
+
+void ListAuthenticationLogsRequest::setToTime(long toTime) {
+  toTime_ = toTime;
+  setParameter(std::string("ToTime"), std::to_string(toTime));
+}
+
+std::string ListAuthenticationLogsRequest::getUserId() const {
+  return userId_;
+}
+
+void ListAuthenticationLogsRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string ListAuthenticationLogsRequest::getLogTag() const {
+  return logTag_;
+}
+
+void ListAuthenticationLogsRequest::setLogTag(const std::string &logTag) {
+  logTag_ = logTag;
+  setParameter(std::string("LogTag"), logTag);
+}
+
+long ListAuthenticationLogsRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void ListAuthenticationLogsRequest::setPageNumber(long pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+long ListAuthenticationLogsRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListAuthenticationLogsRequest::setPageSize(long pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string ListAuthenticationLogsRequest::getCredentialId() const {
+  return credentialId_;
+}
+
+void ListAuthenticationLogsRequest::setCredentialId(const std::string &credentialId) {
+  credentialId_ = credentialId;
+  setParameter(std::string("CredentialId"), credentialId);
+}
+
+long ListAuthenticationLogsRequest::getFromTime() const {
+  return fromTime_;
+}
+
+void ListAuthenticationLogsRequest::setFromTime(long fromTime) {
+  fromTime_ = fromTime;
+  setParameter(std::string("FromTime"), std::to_string(fromTime));
+}
+
+std::string ListAuthenticationLogsRequest::getAuthenticatorUuid() const {
+  return authenticatorUuid_;
+}
+
+void ListAuthenticationLogsRequest::setAuthenticatorUuid(const std::string &authenticatorUuid) {
+  authenticatorUuid_ = authenticatorUuid;
+  setParameter(std::string("AuthenticatorUuid"), authenticatorUuid);
+}
+
+std::string ListAuthenticationLogsRequest::getAuthenticatorType() const {
+  return authenticatorType_;
+}
+
+void ListAuthenticationLogsRequest::setAuthenticatorType(const std::string &authenticatorType) {
+  authenticatorType_ = authenticatorType;
+  setParameter(std::string("AuthenticatorType"), authenticatorType);
+}
+
+std::string ListAuthenticationLogsRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void ListAuthenticationLogsRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/ListAuthenticationLogsResult.cc

@@ -0,0 +1,116 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/idaas-doraemon/model/ListAuthenticationLogsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+ListAuthenticationLogsResult::ListAuthenticationLogsResult() :
+	ServiceResult()
+{}
+
+ListAuthenticationLogsResult::ListAuthenticationLogsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListAuthenticationLogsResult::~ListAuthenticationLogsResult()
+{}
+
+void ListAuthenticationLogsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAuthenticationLogContentNode = value["AuthenticationLogContent"]["authenticationLogContentItem"];
+	for (auto valueAuthenticationLogContentauthenticationLogContentItem : allAuthenticationLogContentNode)
+	{
+		AuthenticationLogContentItem authenticationLogContentObject;
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["TenantId"].isNull())
+			authenticationLogContentObject.tenantId = valueAuthenticationLogContentauthenticationLogContentItem["TenantId"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["AliUid"].isNull())
+			authenticationLogContentObject.aliUid = valueAuthenticationLogContentauthenticationLogContentItem["AliUid"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["ApplicationUuid"].isNull())
+			authenticationLogContentObject.applicationUuid = valueAuthenticationLogContentauthenticationLogContentItem["ApplicationUuid"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["ApplicationExternalId"].isNull())
+			authenticationLogContentObject.applicationExternalId = valueAuthenticationLogContentauthenticationLogContentItem["ApplicationExternalId"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["UserId"].isNull())
+			authenticationLogContentObject.userId = valueAuthenticationLogContentauthenticationLogContentItem["UserId"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorUuid"].isNull())
+			authenticationLogContentObject.authenticatorUuid = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorUuid"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorName"].isNull())
+			authenticationLogContentObject.authenticatorName = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorName"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["CredentialId"].isNull())
+			authenticationLogContentObject.credentialId = valueAuthenticationLogContentauthenticationLogContentItem["CredentialId"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorType"].isNull())
+			authenticationLogContentObject.authenticatorType = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorType"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticationAction"].isNull())
+			authenticationLogContentObject.authenticationAction = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticationAction"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["ChallengeBase64"].isNull())
+			authenticationLogContentObject.challengeBase64 = valueAuthenticationLogContentauthenticationLogContentItem["ChallengeBase64"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticationTime"].isNull())
+			authenticationLogContentObject.authenticationTime = std::stol(valueAuthenticationLogContentauthenticationLogContentItem["AuthenticationTime"].asString());
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["UserAgent"].isNull())
+			authenticationLogContentObject.userAgent = valueAuthenticationLogContentauthenticationLogContentItem["UserAgent"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["UserSourceIp"].isNull())
+			authenticationLogContentObject.userSourceIp = valueAuthenticationLogContentauthenticationLogContentItem["UserSourceIp"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["RawAuthenticationContext"].isNull())
+			authenticationLogContentObject.rawAuthenticationContext = valueAuthenticationLogContentauthenticationLogContentItem["RawAuthenticationContext"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["VerifyResult"].isNull())
+			authenticationLogContentObject.verifyResult = valueAuthenticationLogContentauthenticationLogContentItem["VerifyResult"].asString() == "true";
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["ErrorCode"].isNull())
+			authenticationLogContentObject.errorCode = valueAuthenticationLogContentauthenticationLogContentItem["ErrorCode"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["ErrorMessage"].isNull())
+			authenticationLogContentObject.errorMessage = valueAuthenticationLogContentauthenticationLogContentItem["ErrorMessage"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["LogTag"].isNull())
+			authenticationLogContentObject.logTag = valueAuthenticationLogContentauthenticationLogContentItem["LogTag"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["LogParams"].isNull())
+			authenticationLogContentObject.logParams = valueAuthenticationLogContentauthenticationLogContentItem["LogParams"].asString();
+		authenticationLogContent_.push_back(authenticationLogContentObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+
+}
+
+long ListAuthenticationLogsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<ListAuthenticationLogsResult::AuthenticationLogContentItem> ListAuthenticationLogsResult::getAuthenticationLogContent()const
+{
+	return authenticationLogContent_;
+}
+
+long ListAuthenticationLogsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+long ListAuthenticationLogsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

idaas-doraemon/src/model/ListAuthenticatorOpsLogsRequest.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/idaas-doraemon/model/ListAuthenticatorOpsLogsRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::ListAuthenticatorOpsLogsRequest;
+
+ListAuthenticatorOpsLogsRequest::ListAuthenticatorOpsLogsRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ListAuthenticatorOpsLogs") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListAuthenticatorOpsLogsRequest::~ListAuthenticatorOpsLogsRequest() {}
+
+long ListAuthenticatorOpsLogsRequest::getToTime() const {
+  return toTime_;
+}
+
+void ListAuthenticatorOpsLogsRequest::setToTime(long toTime) {
+  toTime_ = toTime;
+  setParameter(std::string("ToTime"), std::to_string(toTime));
+}
+
+std::string ListAuthenticatorOpsLogsRequest::getUserId() const {
+  return userId_;
+}
+
+void ListAuthenticatorOpsLogsRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+long ListAuthenticatorOpsLogsRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void ListAuthenticatorOpsLogsRequest::setPageNumber(long pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+long ListAuthenticatorOpsLogsRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListAuthenticatorOpsLogsRequest::setPageSize(long pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+long ListAuthenticatorOpsLogsRequest::getFromTime() const {
+  return fromTime_;
+}
+
+void ListAuthenticatorOpsLogsRequest::setFromTime(long fromTime) {
+  fromTime_ = fromTime;
+  setParameter(std::string("FromTime"), std::to_string(fromTime));
+}
+
+std::string ListAuthenticatorOpsLogsRequest::getAuthenticatorUuid() const {
+  return authenticatorUuid_;
+}
+
+void ListAuthenticatorOpsLogsRequest::setAuthenticatorUuid(const std::string &authenticatorUuid) {
+  authenticatorUuid_ = authenticatorUuid;
+  setParameter(std::string("AuthenticatorUuid"), authenticatorUuid);
+}
+
+std::string ListAuthenticatorOpsLogsRequest::getAuthenticatorType() const {
+  return authenticatorType_;
+}
+
+void ListAuthenticatorOpsLogsRequest::setAuthenticatorType(const std::string &authenticatorType) {
+  authenticatorType_ = authenticatorType;
+  setParameter(std::string("AuthenticatorType"), authenticatorType);
+}
+
+std::string ListAuthenticatorOpsLogsRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void ListAuthenticatorOpsLogsRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/ListAuthenticatorOpsLogsResult.cc

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/idaas-doraemon/model/ListAuthenticatorOpsLogsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+ListAuthenticatorOpsLogsResult::ListAuthenticatorOpsLogsResult() :
+	ServiceResult()
+{}
+
+ListAuthenticatorOpsLogsResult::ListAuthenticatorOpsLogsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListAuthenticatorOpsLogsResult::~ListAuthenticatorOpsLogsResult()
+{}
+
+void ListAuthenticatorOpsLogsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAuthenticationLogContentNode = value["AuthenticationLogContent"]["authenticationLogContentItem"];
+	for (auto valueAuthenticationLogContentauthenticationLogContentItem : allAuthenticationLogContentNode)
+	{
+		AuthenticationLogContentItem authenticationLogContentObject;
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["TenantId"].isNull())
+			authenticationLogContentObject.tenantId = valueAuthenticationLogContentauthenticationLogContentItem["TenantId"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["AliUid"].isNull())
+			authenticationLogContentObject.aliUid = valueAuthenticationLogContentauthenticationLogContentItem["AliUid"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["ApplicationUuid"].isNull())
+			authenticationLogContentObject.applicationUuid = valueAuthenticationLogContentauthenticationLogContentItem["ApplicationUuid"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["ApplicationExternalId"].isNull())
+			authenticationLogContentObject.applicationExternalId = valueAuthenticationLogContentauthenticationLogContentItem["ApplicationExternalId"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["UserId"].isNull())
+			authenticationLogContentObject.userId = valueAuthenticationLogContentauthenticationLogContentItem["UserId"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorUuid"].isNull())
+			authenticationLogContentObject.authenticatorUuid = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorUuid"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorName"].isNull())
+			authenticationLogContentObject.authenticatorName = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorName"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["CredentialId"].isNull())
+			authenticationLogContentObject.credentialId = valueAuthenticationLogContentauthenticationLogContentItem["CredentialId"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorType"].isNull())
+			authenticationLogContentObject.authenticatorType = valueAuthenticationLogContentauthenticationLogContentItem["AuthenticatorType"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["OperationAction"].isNull())
+			authenticationLogContentObject.operationAction = valueAuthenticationLogContentauthenticationLogContentItem["OperationAction"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["ChallengeBase64"].isNull())
+			authenticationLogContentObject.challengeBase64 = valueAuthenticationLogContentauthenticationLogContentItem["ChallengeBase64"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["OperationTime"].isNull())
+			authenticationLogContentObject.operationTime = std::stol(valueAuthenticationLogContentauthenticationLogContentItem["OperationTime"].asString());
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["UserAgent"].isNull())
+			authenticationLogContentObject.userAgent = valueAuthenticationLogContentauthenticationLogContentItem["UserAgent"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["UserSourceIp"].isNull())
+			authenticationLogContentObject.userSourceIp = valueAuthenticationLogContentauthenticationLogContentItem["UserSourceIp"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["RawContext"].isNull())
+			authenticationLogContentObject.rawContext = valueAuthenticationLogContentauthenticationLogContentItem["RawContext"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["OperationResult"].isNull())
+			authenticationLogContentObject.operationResult = valueAuthenticationLogContentauthenticationLogContentItem["OperationResult"].asString() == "true";
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["ErrorCode"].isNull())
+			authenticationLogContentObject.errorCode = valueAuthenticationLogContentauthenticationLogContentItem["ErrorCode"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["ErrorMessage"].isNull())
+			authenticationLogContentObject.errorMessage = valueAuthenticationLogContentauthenticationLogContentItem["ErrorMessage"].asString();
+		if(!valueAuthenticationLogContentauthenticationLogContentItem["LogParams"].isNull())
+			authenticationLogContentObject.logParams = valueAuthenticationLogContentauthenticationLogContentItem["LogParams"].asString();
+		authenticationLogContent_.push_back(authenticationLogContentObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+
+}
+
+long ListAuthenticatorOpsLogsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<ListAuthenticatorOpsLogsResult::AuthenticationLogContentItem> ListAuthenticatorOpsLogsResult::getAuthenticationLogContent()const
+{
+	return authenticationLogContent_;
+}
+
+long ListAuthenticatorOpsLogsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+long ListAuthenticatorOpsLogsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

idaas-doraemon/src/model/ListAuthenticatorsRequest.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/idaas-doraemon/model/ListAuthenticatorsRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::ListAuthenticatorsRequest;
+
+ListAuthenticatorsRequest::ListAuthenticatorsRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ListAuthenticators") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListAuthenticatorsRequest::~ListAuthenticatorsRequest() {}
+
+std::string ListAuthenticatorsRequest::getUserId() const {
+  return userId_;
+}
+
+void ListAuthenticatorsRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+long ListAuthenticatorsRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void ListAuthenticatorsRequest::setPageNumber(long pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+long ListAuthenticatorsRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void ListAuthenticatorsRequest::setPageSize(long pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string ListAuthenticatorsRequest::getAuthenticatorType() const {
+  return authenticatorType_;
+}
+
+void ListAuthenticatorsRequest::setAuthenticatorType(const std::string &authenticatorType) {
+  authenticatorType_ = authenticatorType;
+  setParameter(std::string("AuthenticatorType"), authenticatorType);
+}
+
+std::string ListAuthenticatorsRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void ListAuthenticatorsRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/ListAuthenticatorsResult.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/idaas-doraemon/model/ListAuthenticatorsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+ListAuthenticatorsResult::ListAuthenticatorsResult() :
+	ServiceResult()
+{}
+
+ListAuthenticatorsResult::ListAuthenticatorsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListAuthenticatorsResult::~ListAuthenticatorsResult()
+{}
+
+void ListAuthenticatorsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAuthenticatorNode = value["Authenticator"]["AuthenticatorListDTO"];
+	for (auto valueAuthenticatorAuthenticatorListDTO : allAuthenticatorNode)
+	{
+		AuthenticatorListDTO authenticatorObject;
+		if(!valueAuthenticatorAuthenticatorListDTO["ApplicationExternalId"].isNull())
+			authenticatorObject.applicationExternalId = valueAuthenticatorAuthenticatorListDTO["ApplicationExternalId"].asString();
+		if(!valueAuthenticatorAuthenticatorListDTO["AuthenticatorUuid"].isNull())
+			authenticatorObject.authenticatorUuid = valueAuthenticatorAuthenticatorListDTO["AuthenticatorUuid"].asString();
+		if(!valueAuthenticatorAuthenticatorListDTO["CredentialId"].isNull())
+			authenticatorObject.credentialId = valueAuthenticatorAuthenticatorListDTO["CredentialId"].asString();
+		if(!valueAuthenticatorAuthenticatorListDTO["Type"].isNull())
+			authenticatorObject.type = valueAuthenticatorAuthenticatorListDTO["Type"].asString();
+		if(!valueAuthenticatorAuthenticatorListDTO["AuthenticatorName"].isNull())
+			authenticatorObject.authenticatorName = valueAuthenticatorAuthenticatorListDTO["AuthenticatorName"].asString();
+		if(!valueAuthenticatorAuthenticatorListDTO["RegisterTime"].isNull())
+			authenticatorObject.registerTime = std::stol(valueAuthenticatorAuthenticatorListDTO["RegisterTime"].asString());
+		if(!valueAuthenticatorAuthenticatorListDTO["LastVerifyTime"].isNull())
+			authenticatorObject.lastVerifyTime = std::stol(valueAuthenticatorAuthenticatorListDTO["LastVerifyTime"].asString());
+		authenticator_.push_back(authenticatorObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+
+}
+
+long ListAuthenticatorsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+long ListAuthenticatorsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+long ListAuthenticatorsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<ListAuthenticatorsResult::AuthenticatorListDTO> ListAuthenticatorsResult::getAuthenticator()const
+{
+	return authenticator_;
+}
+

idaas-doraemon/src/model/ListPwnedPasswordsRequest.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/idaas-doraemon/model/ListPwnedPasswordsRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::ListPwnedPasswordsRequest;
+
+ListPwnedPasswordsRequest::ListPwnedPasswordsRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ListPwnedPasswords") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListPwnedPasswordsRequest::~ListPwnedPasswordsRequest() {}
+
+std::string ListPwnedPasswordsRequest::getPrefixHexPasswordSha1Hash() const {
+  return prefixHexPasswordSha1Hash_;
+}
+
+void ListPwnedPasswordsRequest::setPrefixHexPasswordSha1Hash(const std::string &prefixHexPasswordSha1Hash) {
+  prefixHexPasswordSha1Hash_ = prefixHexPasswordSha1Hash;
+  setParameter(std::string("PrefixHexPasswordSha1Hash"), prefixHexPasswordSha1Hash);
+}
+

idaas-doraemon/src/model/ListPwnedPasswordsResult.cc

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/idaas-doraemon/model/ListPwnedPasswordsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+ListPwnedPasswordsResult::ListPwnedPasswordsResult() :
+	ServiceResult()
+{}
+
+ListPwnedPasswordsResult::ListPwnedPasswordsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListPwnedPasswordsResult::~ListPwnedPasswordsResult()
+{}
+
+void ListPwnedPasswordsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPwnedPasswordInfosNode = value["PwnedPasswordInfos"]["items"];
+	for (auto valuePwnedPasswordInfositems : allPwnedPasswordInfosNode)
+	{
+		Items pwnedPasswordInfosObject;
+		if(!valuePwnedPasswordInfositems["HexPasswordSha1Hash"].isNull())
+			pwnedPasswordInfosObject.hexPasswordSha1Hash = valuePwnedPasswordInfositems["HexPasswordSha1Hash"].asString();
+		if(!valuePwnedPasswordInfositems["PwnedCount"].isNull())
+			pwnedPasswordInfosObject.pwnedCount = std::stol(valuePwnedPasswordInfositems["PwnedCount"].asString());
+		pwnedPasswordInfos_.push_back(pwnedPasswordInfosObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+
+}
+
+long ListPwnedPasswordsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+long ListPwnedPasswordsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+long ListPwnedPasswordsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<ListPwnedPasswordsResult::Items> ListPwnedPasswordsResult::getPwnedPasswordInfos()const
+{
+	return pwnedPasswordInfos_;
+}
+

idaas-doraemon/src/model/ListUsersRequest.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/idaas-doraemon/model/ListUsersRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::ListUsersRequest;
+
+ListUsersRequest::ListUsersRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ListUsers") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListUsersRequest::~ListUsersRequest() {}
+
+std::string ListUsersRequest::getUserId() const {
+  return userId_;
+}
+
+void ListUsersRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string ListUsersRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void ListUsersRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/ListUsersResult.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/idaas-doraemon/model/ListUsersResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+ListUsersResult::ListUsersResult() :
+	ServiceResult()
+{}
+
+ListUsersResult::ListUsersResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListUsersResult::~ListUsersResult()
+{}
+
+void ListUsersResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allUsersNode = value["Users"]["usersItem"];
+	for (auto valueUsersusersItem : allUsersNode)
+	{
+		UsersItem usersObject;
+		if(!valueUsersusersItem["UserId"].isNull())
+			usersObject.userId = valueUsersusersItem["UserId"].asString();
+		if(!valueUsersusersItem["UserName"].isNull())
+			usersObject.userName = valueUsersusersItem["UserName"].asString();
+		if(!valueUsersusersItem["UserDisplayName"].isNull())
+			usersObject.userDisplayName = valueUsersusersItem["UserDisplayName"].asString();
+		users_.push_back(usersObject);
+	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+
+}
+
+long ListUsersResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<ListUsersResult::UsersItem> ListUsersResult::getUsers()const
+{
+	return users_;
+}
+

idaas-doraemon/src/model/RegisterAuthenticatorRequest.cc

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/idaas-doraemon/model/RegisterAuthenticatorRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::RegisterAuthenticatorRequest;
+
+RegisterAuthenticatorRequest::RegisterAuthenticatorRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "RegisterAuthenticator") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+RegisterAuthenticatorRequest::~RegisterAuthenticatorRequest() {}
+
+std::string RegisterAuthenticatorRequest::getLogParams() const {
+  return logParams_;
+}
+
+void RegisterAuthenticatorRequest::setLogParams(const std::string &logParams) {
+  logParams_ = logParams;
+  setParameter(std::string("LogParams"), logParams);
+}
+
+std::string RegisterAuthenticatorRequest::getClientExtendParamsJson() const {
+  return clientExtendParamsJson_;
+}
+
+void RegisterAuthenticatorRequest::setClientExtendParamsJson(const std::string &clientExtendParamsJson) {
+  clientExtendParamsJson_ = clientExtendParamsJson;
+  setParameter(std::string("ClientExtendParamsJson"), clientExtendParamsJson);
+}
+
+std::string RegisterAuthenticatorRequest::getUserId() const {
+  return userId_;
+}
+
+void RegisterAuthenticatorRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string RegisterAuthenticatorRequest::getServerExtendParamsJson() const {
+  return serverExtendParamsJson_;
+}
+
+void RegisterAuthenticatorRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) {
+  serverExtendParamsJson_ = serverExtendParamsJson;
+  setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson);
+}
+
+std::string RegisterAuthenticatorRequest::getRegistrationContext() const {
+  return registrationContext_;
+}
+
+void RegisterAuthenticatorRequest::setRegistrationContext(const std::string &registrationContext) {
+  registrationContext_ = registrationContext;
+  setParameter(std::string("RegistrationContext"), registrationContext);
+}
+
+std::string RegisterAuthenticatorRequest::getAuthenticatorName() const {
+  return authenticatorName_;
+}
+
+void RegisterAuthenticatorRequest::setAuthenticatorName(const std::string &authenticatorName) {
+  authenticatorName_ = authenticatorName;
+  setParameter(std::string("AuthenticatorName"), authenticatorName);
+}
+
+std::string RegisterAuthenticatorRequest::getRequireChallengeBase64() const {
+  return requireChallengeBase64_;
+}
+
+void RegisterAuthenticatorRequest::setRequireChallengeBase64(const std::string &requireChallengeBase64) {
+  requireChallengeBase64_ = requireChallengeBase64;
+  setParameter(std::string("RequireChallengeBase64"), requireChallengeBase64);
+}
+
+std::string RegisterAuthenticatorRequest::getAuthenticatorType() const {
+  return authenticatorType_;
+}
+
+void RegisterAuthenticatorRequest::setAuthenticatorType(const std::string &authenticatorType) {
+  authenticatorType_ = authenticatorType;
+  setParameter(std::string("AuthenticatorType"), authenticatorType);
+}
+
+std::string RegisterAuthenticatorRequest::getClientExtendParamsJsonSign() const {
+  return clientExtendParamsJsonSign_;
+}
+
+void RegisterAuthenticatorRequest::setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign) {
+  clientExtendParamsJsonSign_ = clientExtendParamsJsonSign;
+  setParameter(std::string("ClientExtendParamsJsonSign"), clientExtendParamsJsonSign);
+}
+
+std::string RegisterAuthenticatorRequest::getUserSourceIp() const {
+  return userSourceIp_;
+}
+
+void RegisterAuthenticatorRequest::setUserSourceIp(const std::string &userSourceIp) {
+  userSourceIp_ = userSourceIp;
+  setParameter(std::string("UserSourceIp"), userSourceIp);
+}
+
+std::string RegisterAuthenticatorRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void RegisterAuthenticatorRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/RegisterAuthenticatorResult.cc

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/idaas-doraemon/model/RegisterAuthenticatorResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+RegisterAuthenticatorResult::RegisterAuthenticatorResult() :
+	ServiceResult()
+{}
+
+RegisterAuthenticatorResult::RegisterAuthenticatorResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RegisterAuthenticatorResult::~RegisterAuthenticatorResult()
+{}
+
+void RegisterAuthenticatorResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["AuthenticatorUuid"].isNull())
+		authenticatorUuid_ = value["AuthenticatorUuid"].asString();
+	if(!value["EtasResponseSting"].isNull())
+		etasResponseSting_ = value["EtasResponseSting"].asString();
+
+}
+
+std::string RegisterAuthenticatorResult::getEtasResponseSting()const
+{
+	return etasResponseSting_;
+}
+
+std::string RegisterAuthenticatorResult::getAuthenticatorUuid()const
+{
+	return authenticatorUuid_;
+}
+

idaas-doraemon/src/model/ServiceInvokeRequest.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/idaas-doraemon/model/ServiceInvokeRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::ServiceInvokeRequest;
+
+ServiceInvokeRequest::ServiceInvokeRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "ServiceInvoke") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ServiceInvokeRequest::~ServiceInvokeRequest() {}
+
+std::string ServiceInvokeRequest::getXClientIp() const {
+  return xClientIp_;
+}
+
+void ServiceInvokeRequest::setXClientIp(const std::string &xClientIp) {
+  xClientIp_ = xClientIp;
+  setParameter(std::string("XClientIp"), xClientIp);
+}
+
+std::string ServiceInvokeRequest::getMobileExtendParamsJsonSign() const {
+  return mobileExtendParamsJsonSign_;
+}
+
+void ServiceInvokeRequest::setMobileExtendParamsJsonSign(const std::string &mobileExtendParamsJsonSign) {
+  mobileExtendParamsJsonSign_ = mobileExtendParamsJsonSign;
+  setParameter(std::string("MobileExtendParamsJsonSign"), mobileExtendParamsJsonSign);
+}
+
+std::string ServiceInvokeRequest::getServerExtendParamsJson() const {
+  return serverExtendParamsJson_;
+}
+
+void ServiceInvokeRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) {
+  serverExtendParamsJson_ = serverExtendParamsJson;
+  setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson);
+}
+
+std::string ServiceInvokeRequest::getDoraemonAction() const {
+  return doraemonAction_;
+}
+
+void ServiceInvokeRequest::setDoraemonAction(const std::string &doraemonAction) {
+  doraemonAction_ = doraemonAction;
+  setParameter(std::string("DoraemonAction"), doraemonAction);
+}
+
+std::string ServiceInvokeRequest::getMobileExtendParamsJson() const {
+  return mobileExtendParamsJson_;
+}
+
+void ServiceInvokeRequest::setMobileExtendParamsJson(const std::string &mobileExtendParamsJson) {
+  mobileExtendParamsJson_ = mobileExtendParamsJson;
+  setParameter(std::string("MobileExtendParamsJson"), mobileExtendParamsJson);
+}
+
+std::string ServiceInvokeRequest::getServiceCode() const {
+  return serviceCode_;
+}
+
+void ServiceInvokeRequest::setServiceCode(const std::string &serviceCode) {
+  serviceCode_ = serviceCode;
+  setParameter(std::string("ServiceCode"), serviceCode);
+}
+
+bool ServiceInvokeRequest::getTestModel() const {
+  return testModel_;
+}
+
+void ServiceInvokeRequest::setTestModel(bool testModel) {
+  testModel_ = testModel;
+  setParameter(std::string("TestModel"), testModel ? "true" : "false");
+}
+
+std::string ServiceInvokeRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void ServiceInvokeRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/ServiceInvokeResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/idaas-doraemon/model/ServiceInvokeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+ServiceInvokeResult::ServiceInvokeResult() :
+	ServiceResult()
+{}
+
+ServiceInvokeResult::ServiceInvokeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ServiceInvokeResult::~ServiceInvokeResult()
+{}
+
+void ServiceInvokeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["IdToken"].isNull())
+		idToken_ = value["IdToken"].asString();
+
+}
+
+std::string ServiceInvokeResult::getIdToken()const
+{
+	return idToken_;
+}
+
+std::string ServiceInvokeResult::getMessage()const
+{
+	return message_;
+}
+
+std::string ServiceInvokeResult::getData()const
+{
+	return data_;
+}
+
+std::string ServiceInvokeResult::getCode()const
+{
+	return code_;
+}
+
+bool ServiceInvokeResult::getSuccess()const
+{
+	return success_;
+}
+

idaas-doraemon/src/model/UpdateAuthenticatorAttributeRequest.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/idaas-doraemon/model/UpdateAuthenticatorAttributeRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::UpdateAuthenticatorAttributeRequest;
+
+UpdateAuthenticatorAttributeRequest::UpdateAuthenticatorAttributeRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "UpdateAuthenticatorAttribute") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateAuthenticatorAttributeRequest::~UpdateAuthenticatorAttributeRequest() {}
+
+std::string UpdateAuthenticatorAttributeRequest::getUserId() const {
+  return userId_;
+}
+
+void UpdateAuthenticatorAttributeRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string UpdateAuthenticatorAttributeRequest::getAuthenticatorName() const {
+  return authenticatorName_;
+}
+
+void UpdateAuthenticatorAttributeRequest::setAuthenticatorName(const std::string &authenticatorName) {
+  authenticatorName_ = authenticatorName;
+  setParameter(std::string("AuthenticatorName"), authenticatorName);
+}
+
+std::string UpdateAuthenticatorAttributeRequest::getAuthenticatorUuid() const {
+  return authenticatorUuid_;
+}
+
+void UpdateAuthenticatorAttributeRequest::setAuthenticatorUuid(const std::string &authenticatorUuid) {
+  authenticatorUuid_ = authenticatorUuid;
+  setParameter(std::string("AuthenticatorUuid"), authenticatorUuid);
+}
+
+std::string UpdateAuthenticatorAttributeRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void UpdateAuthenticatorAttributeRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/UpdateAuthenticatorAttributeResult.cc

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

idaas-doraemon/src/model/VerifyIdTokenRequest.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/idaas-doraemon/model/VerifyIdTokenRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::VerifyIdTokenRequest;
+
+VerifyIdTokenRequest::VerifyIdTokenRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "VerifyIdToken") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+VerifyIdTokenRequest::~VerifyIdTokenRequest() {}
+
+std::string VerifyIdTokenRequest::getJwtIdToken() const {
+  return jwtIdToken_;
+}
+
+void VerifyIdTokenRequest::setJwtIdToken(const std::string &jwtIdToken) {
+  jwtIdToken_ = jwtIdToken;
+  setParameter(std::string("JwtIdToken"), jwtIdToken);
+}
+
+std::string VerifyIdTokenRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void VerifyIdTokenRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/VerifyIdTokenResult.cc

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

idaas-doraemon/src/model/VerifyUserAuthenticationRequest.cc

@@ -0,0 +1,135 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/idaas-doraemon/model/VerifyUserAuthenticationRequest.h>
+
+using AlibabaCloud::Idaas_doraemon::Model::VerifyUserAuthenticationRequest;
+
+VerifyUserAuthenticationRequest::VerifyUserAuthenticationRequest()
+    : RpcServiceRequest("idaas-doraemon", "2021-05-20", "VerifyUserAuthentication") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+VerifyUserAuthenticationRequest::~VerifyUserAuthenticationRequest() {}
+
+std::string VerifyUserAuthenticationRequest::getLogParams() const {
+  return logParams_;
+}
+
+void VerifyUserAuthenticationRequest::setLogParams(const std::string &logParams) {
+  logParams_ = logParams;
+  setParameter(std::string("LogParams"), logParams);
+}
+
+std::string VerifyUserAuthenticationRequest::getClientExtendParamsJson() const {
+  return clientExtendParamsJson_;
+}
+
+void VerifyUserAuthenticationRequest::setClientExtendParamsJson(const std::string &clientExtendParamsJson) {
+  clientExtendParamsJson_ = clientExtendParamsJson;
+  setParameter(std::string("ClientExtendParamsJson"), clientExtendParamsJson);
+}
+
+std::string VerifyUserAuthenticationRequest::getUserId() const {
+  return userId_;
+}
+
+void VerifyUserAuthenticationRequest::setUserId(const std::string &userId) {
+  userId_ = userId;
+  setParameter(std::string("UserId"), userId);
+}
+
+std::string VerifyUserAuthenticationRequest::getLogTag() const {
+  return logTag_;
+}
+
+void VerifyUserAuthenticationRequest::setLogTag(const std::string &logTag) {
+  logTag_ = logTag;
+  setParameter(std::string("LogTag"), logTag);
+}
+
+std::string VerifyUserAuthenticationRequest::getServerExtendParamsJson() const {
+  return serverExtendParamsJson_;
+}
+
+void VerifyUserAuthenticationRequest::setServerExtendParamsJson(const std::string &serverExtendParamsJson) {
+  serverExtendParamsJson_ = serverExtendParamsJson;
+  setParameter(std::string("ServerExtendParamsJson"), serverExtendParamsJson);
+}
+
+std::string VerifyUserAuthenticationRequest::getRequireBindHashBase64() const {
+  return requireBindHashBase64_;
+}
+
+void VerifyUserAuthenticationRequest::setRequireBindHashBase64(const std::string &requireBindHashBase64) {
+  requireBindHashBase64_ = requireBindHashBase64;
+  setParameter(std::string("RequireBindHashBase64"), requireBindHashBase64);
+}
+
+std::string VerifyUserAuthenticationRequest::getAuthenticationContext() const {
+  return authenticationContext_;
+}
+
+void VerifyUserAuthenticationRequest::setAuthenticationContext(const std::string &authenticationContext) {
+  authenticationContext_ = authenticationContext;
+  setParameter(std::string("AuthenticationContext"), authenticationContext);
+}
+
+std::string VerifyUserAuthenticationRequest::getRequireChallengeBase64() const {
+  return requireChallengeBase64_;
+}
+
+void VerifyUserAuthenticationRequest::setRequireChallengeBase64(const std::string &requireChallengeBase64) {
+  requireChallengeBase64_ = requireChallengeBase64;
+  setParameter(std::string("RequireChallengeBase64"), requireChallengeBase64);
+}
+
+std::string VerifyUserAuthenticationRequest::getAuthenticatorType() const {
+  return authenticatorType_;
+}
+
+void VerifyUserAuthenticationRequest::setAuthenticatorType(const std::string &authenticatorType) {
+  authenticatorType_ = authenticatorType;
+  setParameter(std::string("AuthenticatorType"), authenticatorType);
+}
+
+std::string VerifyUserAuthenticationRequest::getClientExtendParamsJsonSign() const {
+  return clientExtendParamsJsonSign_;
+}
+
+void VerifyUserAuthenticationRequest::setClientExtendParamsJsonSign(const std::string &clientExtendParamsJsonSign) {
+  clientExtendParamsJsonSign_ = clientExtendParamsJsonSign;
+  setParameter(std::string("ClientExtendParamsJsonSign"), clientExtendParamsJsonSign);
+}
+
+std::string VerifyUserAuthenticationRequest::getUserSourceIp() const {
+  return userSourceIp_;
+}
+
+void VerifyUserAuthenticationRequest::setUserSourceIp(const std::string &userSourceIp) {
+  userSourceIp_ = userSourceIp;
+  setParameter(std::string("UserSourceIp"), userSourceIp);
+}
+
+std::string VerifyUserAuthenticationRequest::getApplicationExternalId() const {
+  return applicationExternalId_;
+}
+
+void VerifyUserAuthenticationRequest::setApplicationExternalId(const std::string &applicationExternalId) {
+  applicationExternalId_ = applicationExternalId;
+  setParameter(std::string("ApplicationExternalId"), applicationExternalId);
+}
+

idaas-doraemon/src/model/VerifyUserAuthenticationResult.cc

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/idaas-doraemon/model/VerifyUserAuthenticationResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Idaas_doraemon;
+using namespace AlibabaCloud::Idaas_doraemon::Model;
+
+VerifyUserAuthenticationResult::VerifyUserAuthenticationResult() :
+	ServiceResult()
+{}
+
+VerifyUserAuthenticationResult::VerifyUserAuthenticationResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+VerifyUserAuthenticationResult::~VerifyUserAuthenticationResult()
+{}
+
+void VerifyUserAuthenticationResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto authenticateResultInfoNode = value["AuthenticateResultInfo"];
+	if(!authenticateResultInfoNode["UserId"].isNull())
+		authenticateResultInfo_.userId = authenticateResultInfoNode["UserId"].asString();
+	if(!authenticateResultInfoNode["CredentialId"].isNull())
+		authenticateResultInfo_.credentialId = authenticateResultInfoNode["CredentialId"].asString();
+	if(!authenticateResultInfoNode["BindHashBase64"].isNull())
+		authenticateResultInfo_.bindHashBase64 = authenticateResultInfoNode["BindHashBase64"].asString();
+	if(!value["VerifyResult"].isNull())
+		verifyResult_ = value["VerifyResult"].asString() == "true";
+	if(!value["EtasSDKString"].isNull())
+		etasSDKString_ = value["EtasSDKString"].asString();
+	if(!value["IdToken"].isNull())
+		idToken_ = value["IdToken"].asString();
+
+}
+
+std::string VerifyUserAuthenticationResult::getIdToken()const
+{
+	return idToken_;
+}
+
+VerifyUserAuthenticationResult::AuthenticateResultInfo VerifyUserAuthenticationResult::getAuthenticateResultInfo()const
+{
+	return authenticateResultInfo_;
+}
+
+std::string VerifyUserAuthenticationResult::getEtasSDKString()const
+{
+	return etasSDKString_;
+}
+
+bool VerifyUserAuthenticationResult::getVerifyResult()const
+{
+	return verifyResult_;
+}
+