Supported java

VERSION

@@ -1 +1 @@
-1.36.1489
+1.36.1490

resourcecenter/CMakeLists.txt

@@ -0,0 +1,146 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(resourcecenter_public_header 
+	include/alibabacloud/resourcecenter/ResourceCenterClient.h
+	include/alibabacloud/resourcecenter/ResourceCenterExport.h )
+
+set(resourcecenter_public_header_model 
+	include/alibabacloud/resourcecenter/model/DisableMultiAccountResourceCenterRequest.h
+	include/alibabacloud/resourcecenter/model/DisableMultiAccountResourceCenterResult.h
+	include/alibabacloud/resourcecenter/model/DisableResourceCenterRequest.h
+	include/alibabacloud/resourcecenter/model/DisableResourceCenterResult.h
+	include/alibabacloud/resourcecenter/model/EnableMultiAccountResourceCenterRequest.h
+	include/alibabacloud/resourcecenter/model/EnableMultiAccountResourceCenterResult.h
+	include/alibabacloud/resourcecenter/model/EnableResourceCenterRequest.h
+	include/alibabacloud/resourcecenter/model/EnableResourceCenterResult.h
+	include/alibabacloud/resourcecenter/model/GetMultiAccountResourceCenterServiceStatusRequest.h
+	include/alibabacloud/resourcecenter/model/GetMultiAccountResourceCenterServiceStatusResult.h
+	include/alibabacloud/resourcecenter/model/GetMultiAccountResourceConfigurationRequest.h
+	include/alibabacloud/resourcecenter/model/GetMultiAccountResourceConfigurationResult.h
+	include/alibabacloud/resourcecenter/model/GetResourceCenterServiceStatusRequest.h
+	include/alibabacloud/resourcecenter/model/GetResourceCenterServiceStatusResult.h
+	include/alibabacloud/resourcecenter/model/GetResourceConfigurationRequest.h
+	include/alibabacloud/resourcecenter/model/GetResourceConfigurationResult.h
+	include/alibabacloud/resourcecenter/model/ListMultiAccountResourceGroupsRequest.h
+	include/alibabacloud/resourcecenter/model/ListMultiAccountResourceGroupsResult.h
+	include/alibabacloud/resourcecenter/model/ListMultiAccountTagKeysRequest.h
+	include/alibabacloud/resourcecenter/model/ListMultiAccountTagKeysResult.h
+	include/alibabacloud/resourcecenter/model/ListMultiAccountTagValuesRequest.h
+	include/alibabacloud/resourcecenter/model/ListMultiAccountTagValuesResult.h
+	include/alibabacloud/resourcecenter/model/ListResourceTypesRequest.h
+	include/alibabacloud/resourcecenter/model/ListResourceTypesResult.h
+	include/alibabacloud/resourcecenter/model/ListTagKeysRequest.h
+	include/alibabacloud/resourcecenter/model/ListTagKeysResult.h
+	include/alibabacloud/resourcecenter/model/ListTagValuesRequest.h
+	include/alibabacloud/resourcecenter/model/ListTagValuesResult.h
+	include/alibabacloud/resourcecenter/model/SearchMultiAccountResourcesRequest.h
+	include/alibabacloud/resourcecenter/model/SearchMultiAccountResourcesResult.h
+	include/alibabacloud/resourcecenter/model/SearchResourcesRequest.h
+	include/alibabacloud/resourcecenter/model/SearchResourcesResult.h )
+
+set(resourcecenter_src 
+	src/ResourceCenterClient.cc
+	src/model/DisableMultiAccountResourceCenterRequest.cc
+	src/model/DisableMultiAccountResourceCenterResult.cc
+	src/model/DisableResourceCenterRequest.cc
+	src/model/DisableResourceCenterResult.cc
+	src/model/EnableMultiAccountResourceCenterRequest.cc
+	src/model/EnableMultiAccountResourceCenterResult.cc
+	src/model/EnableResourceCenterRequest.cc
+	src/model/EnableResourceCenterResult.cc
+	src/model/GetMultiAccountResourceCenterServiceStatusRequest.cc
+	src/model/GetMultiAccountResourceCenterServiceStatusResult.cc
+	src/model/GetMultiAccountResourceConfigurationRequest.cc
+	src/model/GetMultiAccountResourceConfigurationResult.cc
+	src/model/GetResourceCenterServiceStatusRequest.cc
+	src/model/GetResourceCenterServiceStatusResult.cc
+	src/model/GetResourceConfigurationRequest.cc
+	src/model/GetResourceConfigurationResult.cc
+	src/model/ListMultiAccountResourceGroupsRequest.cc
+	src/model/ListMultiAccountResourceGroupsResult.cc
+	src/model/ListMultiAccountTagKeysRequest.cc
+	src/model/ListMultiAccountTagKeysResult.cc
+	src/model/ListMultiAccountTagValuesRequest.cc
+	src/model/ListMultiAccountTagValuesResult.cc
+	src/model/ListResourceTypesRequest.cc
+	src/model/ListResourceTypesResult.cc
+	src/model/ListTagKeysRequest.cc
+	src/model/ListTagKeysResult.cc
+	src/model/ListTagValuesRequest.cc
+	src/model/ListTagValuesResult.cc
+	src/model/SearchMultiAccountResourcesRequest.cc
+	src/model/SearchMultiAccountResourcesResult.cc
+	src/model/SearchResourcesRequest.cc
+	src/model/SearchResourcesResult.cc )
+
+add_library(resourcecenter ${LIB_TYPE}
+	${resourcecenter_public_header}
+	${resourcecenter_public_header_model}
+	${resourcecenter_src})
+
+set_target_properties(resourcecenter
+	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}resourcecenter
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(resourcecenter
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_RESOURCECENTER_LIBRARY)
+endif()
+
+target_include_directories(resourcecenter
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(resourcecenter
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(resourcecenter
+		jsoncpp)
+	target_include_directories(resourcecenter
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(resourcecenter
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(resourcecenter
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(resourcecenter
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(resourcecenter
+		jsoncpp)
+endif()
+
+install(FILES ${resourcecenter_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/resourcecenter)
+install(FILES ${resourcecenter_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/resourcecenter/model)
+install(TARGETS resourcecenter
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

resourcecenter/include/alibabacloud/resourcecenter/ResourceCenterClient.h

@@ -0,0 +1,174 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RESOURCECENTER_RESOURCECENTERCLIENT_H_
+#define ALIBABACLOUD_RESOURCECENTER_RESOURCECENTERCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ResourceCenterExport.h"
+#include "model/DisableMultiAccountResourceCenterRequest.h"
+#include "model/DisableMultiAccountResourceCenterResult.h"
+#include "model/DisableResourceCenterRequest.h"
+#include "model/DisableResourceCenterResult.h"
+#include "model/EnableMultiAccountResourceCenterRequest.h"
+#include "model/EnableMultiAccountResourceCenterResult.h"
+#include "model/EnableResourceCenterRequest.h"
+#include "model/EnableResourceCenterResult.h"
+#include "model/GetMultiAccountResourceCenterServiceStatusRequest.h"
+#include "model/GetMultiAccountResourceCenterServiceStatusResult.h"
+#include "model/GetMultiAccountResourceConfigurationRequest.h"
+#include "model/GetMultiAccountResourceConfigurationResult.h"
+#include "model/GetResourceCenterServiceStatusRequest.h"
+#include "model/GetResourceCenterServiceStatusResult.h"
+#include "model/GetResourceConfigurationRequest.h"
+#include "model/GetResourceConfigurationResult.h"
+#include "model/ListMultiAccountResourceGroupsRequest.h"
+#include "model/ListMultiAccountResourceGroupsResult.h"
+#include "model/ListMultiAccountTagKeysRequest.h"
+#include "model/ListMultiAccountTagKeysResult.h"
+#include "model/ListMultiAccountTagValuesRequest.h"
+#include "model/ListMultiAccountTagValuesResult.h"
+#include "model/ListResourceTypesRequest.h"
+#include "model/ListResourceTypesResult.h"
+#include "model/ListTagKeysRequest.h"
+#include "model/ListTagKeysResult.h"
+#include "model/ListTagValuesRequest.h"
+#include "model/ListTagValuesResult.h"
+#include "model/SearchMultiAccountResourcesRequest.h"
+#include "model/SearchMultiAccountResourcesResult.h"
+#include "model/SearchResourcesRequest.h"
+#include "model/SearchResourcesResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		class ALIBABACLOUD_RESOURCECENTER_EXPORT ResourceCenterClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::DisableMultiAccountResourceCenterResult> DisableMultiAccountResourceCenterOutcome;
+			typedef std::future<DisableMultiAccountResourceCenterOutcome> DisableMultiAccountResourceCenterOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::DisableMultiAccountResourceCenterRequest&, const DisableMultiAccountResourceCenterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableMultiAccountResourceCenterAsyncHandler;
+			typedef Outcome<Error, Model::DisableResourceCenterResult> DisableResourceCenterOutcome;
+			typedef std::future<DisableResourceCenterOutcome> DisableResourceCenterOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::DisableResourceCenterRequest&, const DisableResourceCenterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableResourceCenterAsyncHandler;
+			typedef Outcome<Error, Model::EnableMultiAccountResourceCenterResult> EnableMultiAccountResourceCenterOutcome;
+			typedef std::future<EnableMultiAccountResourceCenterOutcome> EnableMultiAccountResourceCenterOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::EnableMultiAccountResourceCenterRequest&, const EnableMultiAccountResourceCenterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableMultiAccountResourceCenterAsyncHandler;
+			typedef Outcome<Error, Model::EnableResourceCenterResult> EnableResourceCenterOutcome;
+			typedef std::future<EnableResourceCenterOutcome> EnableResourceCenterOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::EnableResourceCenterRequest&, const EnableResourceCenterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableResourceCenterAsyncHandler;
+			typedef Outcome<Error, Model::GetMultiAccountResourceCenterServiceStatusResult> GetMultiAccountResourceCenterServiceStatusOutcome;
+			typedef std::future<GetMultiAccountResourceCenterServiceStatusOutcome> GetMultiAccountResourceCenterServiceStatusOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::GetMultiAccountResourceCenterServiceStatusRequest&, const GetMultiAccountResourceCenterServiceStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMultiAccountResourceCenterServiceStatusAsyncHandler;
+			typedef Outcome<Error, Model::GetMultiAccountResourceConfigurationResult> GetMultiAccountResourceConfigurationOutcome;
+			typedef std::future<GetMultiAccountResourceConfigurationOutcome> GetMultiAccountResourceConfigurationOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::GetMultiAccountResourceConfigurationRequest&, const GetMultiAccountResourceConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMultiAccountResourceConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::GetResourceCenterServiceStatusResult> GetResourceCenterServiceStatusOutcome;
+			typedef std::future<GetResourceCenterServiceStatusOutcome> GetResourceCenterServiceStatusOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::GetResourceCenterServiceStatusRequest&, const GetResourceCenterServiceStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceCenterServiceStatusAsyncHandler;
+			typedef Outcome<Error, Model::GetResourceConfigurationResult> GetResourceConfigurationOutcome;
+			typedef std::future<GetResourceConfigurationOutcome> GetResourceConfigurationOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::GetResourceConfigurationRequest&, const GetResourceConfigurationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetResourceConfigurationAsyncHandler;
+			typedef Outcome<Error, Model::ListMultiAccountResourceGroupsResult> ListMultiAccountResourceGroupsOutcome;
+			typedef std::future<ListMultiAccountResourceGroupsOutcome> ListMultiAccountResourceGroupsOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::ListMultiAccountResourceGroupsRequest&, const ListMultiAccountResourceGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListMultiAccountResourceGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ListMultiAccountTagKeysResult> ListMultiAccountTagKeysOutcome;
+			typedef std::future<ListMultiAccountTagKeysOutcome> ListMultiAccountTagKeysOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::ListMultiAccountTagKeysRequest&, const ListMultiAccountTagKeysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListMultiAccountTagKeysAsyncHandler;
+			typedef Outcome<Error, Model::ListMultiAccountTagValuesResult> ListMultiAccountTagValuesOutcome;
+			typedef std::future<ListMultiAccountTagValuesOutcome> ListMultiAccountTagValuesOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::ListMultiAccountTagValuesRequest&, const ListMultiAccountTagValuesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListMultiAccountTagValuesAsyncHandler;
+			typedef Outcome<Error, Model::ListResourceTypesResult> ListResourceTypesOutcome;
+			typedef std::future<ListResourceTypesOutcome> ListResourceTypesOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::ListResourceTypesRequest&, const ListResourceTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListResourceTypesAsyncHandler;
+			typedef Outcome<Error, Model::ListTagKeysResult> ListTagKeysOutcome;
+			typedef std::future<ListTagKeysOutcome> ListTagKeysOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::ListTagKeysRequest&, const ListTagKeysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagKeysAsyncHandler;
+			typedef Outcome<Error, Model::ListTagValuesResult> ListTagValuesOutcome;
+			typedef std::future<ListTagValuesOutcome> ListTagValuesOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::ListTagValuesRequest&, const ListTagValuesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagValuesAsyncHandler;
+			typedef Outcome<Error, Model::SearchMultiAccountResourcesResult> SearchMultiAccountResourcesOutcome;
+			typedef std::future<SearchMultiAccountResourcesOutcome> SearchMultiAccountResourcesOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::SearchMultiAccountResourcesRequest&, const SearchMultiAccountResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchMultiAccountResourcesAsyncHandler;
+			typedef Outcome<Error, Model::SearchResourcesResult> SearchResourcesOutcome;
+			typedef std::future<SearchResourcesOutcome> SearchResourcesOutcomeCallable;
+			typedef std::function<void(const ResourceCenterClient*, const Model::SearchResourcesRequest&, const SearchResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SearchResourcesAsyncHandler;
+
+			ResourceCenterClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ResourceCenterClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ResourceCenterClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ResourceCenterClient();
+			DisableMultiAccountResourceCenterOutcome disableMultiAccountResourceCenter(const Model::DisableMultiAccountResourceCenterRequest &request)const;
+			void disableMultiAccountResourceCenterAsync(const Model::DisableMultiAccountResourceCenterRequest& request, const DisableMultiAccountResourceCenterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableMultiAccountResourceCenterOutcomeCallable disableMultiAccountResourceCenterCallable(const Model::DisableMultiAccountResourceCenterRequest& request) const;
+			DisableResourceCenterOutcome disableResourceCenter(const Model::DisableResourceCenterRequest &request)const;
+			void disableResourceCenterAsync(const Model::DisableResourceCenterRequest& request, const DisableResourceCenterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DisableResourceCenterOutcomeCallable disableResourceCenterCallable(const Model::DisableResourceCenterRequest& request) const;
+			EnableMultiAccountResourceCenterOutcome enableMultiAccountResourceCenter(const Model::EnableMultiAccountResourceCenterRequest &request)const;
+			void enableMultiAccountResourceCenterAsync(const Model::EnableMultiAccountResourceCenterRequest& request, const EnableMultiAccountResourceCenterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableMultiAccountResourceCenterOutcomeCallable enableMultiAccountResourceCenterCallable(const Model::EnableMultiAccountResourceCenterRequest& request) const;
+			EnableResourceCenterOutcome enableResourceCenter(const Model::EnableResourceCenterRequest &request)const;
+			void enableResourceCenterAsync(const Model::EnableResourceCenterRequest& request, const EnableResourceCenterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			EnableResourceCenterOutcomeCallable enableResourceCenterCallable(const Model::EnableResourceCenterRequest& request) const;
+			GetMultiAccountResourceCenterServiceStatusOutcome getMultiAccountResourceCenterServiceStatus(const Model::GetMultiAccountResourceCenterServiceStatusRequest &request)const;
+			void getMultiAccountResourceCenterServiceStatusAsync(const Model::GetMultiAccountResourceCenterServiceStatusRequest& request, const GetMultiAccountResourceCenterServiceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMultiAccountResourceCenterServiceStatusOutcomeCallable getMultiAccountResourceCenterServiceStatusCallable(const Model::GetMultiAccountResourceCenterServiceStatusRequest& request) const;
+			GetMultiAccountResourceConfigurationOutcome getMultiAccountResourceConfiguration(const Model::GetMultiAccountResourceConfigurationRequest &request)const;
+			void getMultiAccountResourceConfigurationAsync(const Model::GetMultiAccountResourceConfigurationRequest& request, const GetMultiAccountResourceConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetMultiAccountResourceConfigurationOutcomeCallable getMultiAccountResourceConfigurationCallable(const Model::GetMultiAccountResourceConfigurationRequest& request) const;
+			GetResourceCenterServiceStatusOutcome getResourceCenterServiceStatus(const Model::GetResourceCenterServiceStatusRequest &request)const;
+			void getResourceCenterServiceStatusAsync(const Model::GetResourceCenterServiceStatusRequest& request, const GetResourceCenterServiceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetResourceCenterServiceStatusOutcomeCallable getResourceCenterServiceStatusCallable(const Model::GetResourceCenterServiceStatusRequest& request) const;
+			GetResourceConfigurationOutcome getResourceConfiguration(const Model::GetResourceConfigurationRequest &request)const;
+			void getResourceConfigurationAsync(const Model::GetResourceConfigurationRequest& request, const GetResourceConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetResourceConfigurationOutcomeCallable getResourceConfigurationCallable(const Model::GetResourceConfigurationRequest& request) const;
+			ListMultiAccountResourceGroupsOutcome listMultiAccountResourceGroups(const Model::ListMultiAccountResourceGroupsRequest &request)const;
+			void listMultiAccountResourceGroupsAsync(const Model::ListMultiAccountResourceGroupsRequest& request, const ListMultiAccountResourceGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListMultiAccountResourceGroupsOutcomeCallable listMultiAccountResourceGroupsCallable(const Model::ListMultiAccountResourceGroupsRequest& request) const;
+			ListMultiAccountTagKeysOutcome listMultiAccountTagKeys(const Model::ListMultiAccountTagKeysRequest &request)const;
+			void listMultiAccountTagKeysAsync(const Model::ListMultiAccountTagKeysRequest& request, const ListMultiAccountTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListMultiAccountTagKeysOutcomeCallable listMultiAccountTagKeysCallable(const Model::ListMultiAccountTagKeysRequest& request) const;
+			ListMultiAccountTagValuesOutcome listMultiAccountTagValues(const Model::ListMultiAccountTagValuesRequest &request)const;
+			void listMultiAccountTagValuesAsync(const Model::ListMultiAccountTagValuesRequest& request, const ListMultiAccountTagValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListMultiAccountTagValuesOutcomeCallable listMultiAccountTagValuesCallable(const Model::ListMultiAccountTagValuesRequest& request) const;
+			ListResourceTypesOutcome listResourceTypes(const Model::ListResourceTypesRequest &request)const;
+			void listResourceTypesAsync(const Model::ListResourceTypesRequest& request, const ListResourceTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListResourceTypesOutcomeCallable listResourceTypesCallable(const Model::ListResourceTypesRequest& request) const;
+			ListTagKeysOutcome listTagKeys(const Model::ListTagKeysRequest &request)const;
+			void listTagKeysAsync(const Model::ListTagKeysRequest& request, const ListTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTagKeysOutcomeCallable listTagKeysCallable(const Model::ListTagKeysRequest& request) const;
+			ListTagValuesOutcome listTagValues(const Model::ListTagValuesRequest &request)const;
+			void listTagValuesAsync(const Model::ListTagValuesRequest& request, const ListTagValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTagValuesOutcomeCallable listTagValuesCallable(const Model::ListTagValuesRequest& request) const;
+			SearchMultiAccountResourcesOutcome searchMultiAccountResources(const Model::SearchMultiAccountResourcesRequest &request)const;
+			void searchMultiAccountResourcesAsync(const Model::SearchMultiAccountResourcesRequest& request, const SearchMultiAccountResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SearchMultiAccountResourcesOutcomeCallable searchMultiAccountResourcesCallable(const Model::SearchMultiAccountResourcesRequest& request) const;
+			SearchResourcesOutcome searchResources(const Model::SearchResourcesRequest &request)const;
+			void searchResourcesAsync(const Model::SearchResourcesRequest& request, const SearchResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SearchResourcesOutcomeCallable searchResourcesCallable(const Model::SearchResourcesRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_RESOURCECENTER_RESOURCECENTERCLIENT_H_

resourcecenter/include/alibabacloud/resourcecenter/ResourceCenterExport.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_RESOURCECENTER_RESOURCECENTEREXPORT_H_
+#define ALIBABACLOUD_RESOURCECENTER_RESOURCECENTEREXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_RESOURCECENTER_LIBRARY)
+#		define ALIBABACLOUD_RESOURCECENTER_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_RESOURCECENTER_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_RESOURCECENTER_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_RESOURCECENTER_RESOURCECENTEREXPORT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/DisableMultiAccountResourceCenterRequest.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_RESOURCECENTER_MODEL_DISABLEMULTIACCOUNTRESOURCECENTERREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_DISABLEMULTIACCOUNTRESOURCECENTERREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT DisableMultiAccountResourceCenterRequest : public RpcServiceRequest {
+public:
+	DisableMultiAccountResourceCenterRequest();
+	~DisableMultiAccountResourceCenterRequest();
+
+private:
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_DISABLEMULTIACCOUNTRESOURCECENTERREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/DisableMultiAccountResourceCenterResult.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_RESOURCECENTER_MODEL_DISABLEMULTIACCOUNTRESOURCECENTERRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_DISABLEMULTIACCOUNTRESOURCECENTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT DisableMultiAccountResourceCenterResult : public ServiceResult
+			{
+			public:
+
+
+				DisableMultiAccountResourceCenterResult();
+				explicit DisableMultiAccountResourceCenterResult(const std::string &payload);
+				~DisableMultiAccountResourceCenterResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_DISABLEMULTIACCOUNTRESOURCECENTERRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/DisableResourceCenterRequest.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_RESOURCECENTER_MODEL_DISABLERESOURCECENTERREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_DISABLERESOURCECENTERREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT DisableResourceCenterRequest : public RpcServiceRequest {
+public:
+	DisableResourceCenterRequest();
+	~DisableResourceCenterRequest();
+
+private:
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_DISABLERESOURCECENTERREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/DisableResourceCenterResult.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_RESOURCECENTER_MODEL_DISABLERESOURCECENTERRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_DISABLERESOURCECENTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT DisableResourceCenterResult : public ServiceResult
+			{
+			public:
+
+
+				DisableResourceCenterResult();
+				explicit DisableResourceCenterResult(const std::string &payload);
+				~DisableResourceCenterResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_DISABLERESOURCECENTERRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/EnableMultiAccountResourceCenterRequest.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_RESOURCECENTER_MODEL_ENABLEMULTIACCOUNTRESOURCECENTERREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_ENABLEMULTIACCOUNTRESOURCECENTERREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT EnableMultiAccountResourceCenterRequest : public RpcServiceRequest {
+public:
+	EnableMultiAccountResourceCenterRequest();
+	~EnableMultiAccountResourceCenterRequest();
+	std::string getChannel() const;
+	void setChannel(const std::string &channel);
+
+private:
+	std::string channel_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_ENABLEMULTIACCOUNTRESOURCECENTERREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/EnableMultiAccountResourceCenterResult.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_RESOURCECENTER_MODEL_ENABLEMULTIACCOUNTRESOURCECENTERRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_ENABLEMULTIACCOUNTRESOURCECENTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT EnableMultiAccountResourceCenterResult : public ServiceResult
+			{
+			public:
+
+
+				EnableMultiAccountResourceCenterResult();
+				explicit EnableMultiAccountResourceCenterResult(const std::string &payload);
+				~EnableMultiAccountResourceCenterResult();
+				std::string getStatus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_ENABLEMULTIACCOUNTRESOURCECENTERRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/EnableResourceCenterRequest.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_RESOURCECENTER_MODEL_ENABLERESOURCECENTERREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_ENABLERESOURCECENTERREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT EnableResourceCenterRequest : public RpcServiceRequest {
+public:
+	EnableResourceCenterRequest();
+	~EnableResourceCenterRequest();
+	std::string getChannel() const;
+	void setChannel(const std::string &channel);
+
+private:
+	std::string channel_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_ENABLERESOURCECENTERREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/EnableResourceCenterResult.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_RESOURCECENTER_MODEL_ENABLERESOURCECENTERRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_ENABLERESOURCECENTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT EnableResourceCenterResult : public ServiceResult
+			{
+			public:
+
+
+				EnableResourceCenterResult();
+				explicit EnableResourceCenterResult(const std::string &payload);
+				~EnableResourceCenterResult();
+				std::string getStatus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_ENABLERESOURCECENTERRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/GetMultiAccountResourceCenterServiceStatusRequest.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECENTERSERVICESTATUSREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECENTERSERVICESTATUSREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT GetMultiAccountResourceCenterServiceStatusRequest : public RpcServiceRequest {
+public:
+	GetMultiAccountResourceCenterServiceStatusRequest();
+	~GetMultiAccountResourceCenterServiceStatusRequest();
+
+private:
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECENTERSERVICESTATUSREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/GetMultiAccountResourceCenterServiceStatusResult.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_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECENTERSERVICESTATUSRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECENTERSERVICESTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT GetMultiAccountResourceCenterServiceStatusResult : public ServiceResult
+			{
+			public:
+
+
+				GetMultiAccountResourceCenterServiceStatusResult();
+				explicit GetMultiAccountResourceCenterServiceStatusResult(const std::string &payload);
+				~GetMultiAccountResourceCenterServiceStatusResult();
+				std::string getServiceStatus()const;
+				std::string getInitialStatus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string serviceStatus_;
+				std::string initialStatus_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECENTERSERVICESTATUSRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/GetMultiAccountResourceConfigurationRequest.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_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECONFIGURATIONREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT GetMultiAccountResourceConfigurationRequest : public RpcServiceRequest {
+public:
+	GetMultiAccountResourceConfigurationRequest();
+	~GetMultiAccountResourceConfigurationRequest();
+	std::string getResourceId() const;
+	void setResourceId(const std::string &resourceId);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	std::string getAccountId() const;
+	void setAccountId(const std::string &accountId);
+	std::string getResourceRegionId() const;
+	void setResourceRegionId(const std::string &resourceRegionId);
+
+private:
+	std::string resourceId_;
+	std::string resourceType_;
+	std::string accountId_;
+	std::string resourceRegionId_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECONFIGURATIONREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/GetMultiAccountResourceConfigurationResult.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_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECONFIGURATIONRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECONFIGURATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT GetMultiAccountResourceConfigurationResult : public ServiceResult
+			{
+			public:
+
+
+				GetMultiAccountResourceConfigurationResult();
+				explicit GetMultiAccountResourceConfigurationResult(const std::string &payload);
+				~GetMultiAccountResourceConfigurationResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_GETMULTIACCOUNTRESOURCECONFIGURATIONRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/GetResourceCenterServiceStatusRequest.h

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_RESOURCECENTER_MODEL_GETRESOURCECENTERSERVICESTATUSREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_GETRESOURCECENTERSERVICESTATUSREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT GetResourceCenterServiceStatusRequest : public RpcServiceRequest {
+public:
+	GetResourceCenterServiceStatusRequest();
+	~GetResourceCenterServiceStatusRequest();
+
+private:
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_GETRESOURCECENTERSERVICESTATUSREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/GetResourceCenterServiceStatusResult.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_RESOURCECENTER_MODEL_GETRESOURCECENTERSERVICESTATUSRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_GETRESOURCECENTERSERVICESTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT GetResourceCenterServiceStatusResult : public ServiceResult
+			{
+			public:
+
+
+				GetResourceCenterServiceStatusResult();
+				explicit GetResourceCenterServiceStatusResult(const std::string &payload);
+				~GetResourceCenterServiceStatusResult();
+				std::string getServiceStatus()const;
+				std::string getInitialStatus()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string serviceStatus_;
+				std::string initialStatus_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_GETRESOURCECENTERSERVICESTATUSRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/GetResourceConfigurationRequest.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_RESOURCECENTER_MODEL_GETRESOURCECONFIGURATIONREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_GETRESOURCECONFIGURATIONREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT GetResourceConfigurationRequest : public RpcServiceRequest {
+public:
+	GetResourceConfigurationRequest();
+	~GetResourceConfigurationRequest();
+	std::string getResourceId() const;
+	void setResourceId(const std::string &resourceId);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	std::string getResourceRegionId() const;
+	void setResourceRegionId(const std::string &resourceRegionId);
+
+private:
+	std::string resourceId_;
+	std::string resourceType_;
+	std::string resourceRegionId_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_GETRESOURCECONFIGURATIONREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/GetResourceConfigurationResult.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_RESOURCECENTER_MODEL_GETRESOURCECONFIGURATIONRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_GETRESOURCECONFIGURATIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT GetResourceConfigurationResult : public ServiceResult
+			{
+			public:
+
+
+				GetResourceConfigurationResult();
+				explicit GetResourceConfigurationResult(const std::string &payload);
+				~GetResourceConfigurationResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_GETRESOURCECONFIGURATIONRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListMultiAccountResourceGroupsRequest.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_RESOURCECENTER_MODEL_LISTMULTIACCOUNTRESOURCEGROUPSREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTRESOURCEGROUPSREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT ListMultiAccountResourceGroupsRequest : public RpcServiceRequest {
+public:
+	ListMultiAccountResourceGroupsRequest();
+	~ListMultiAccountResourceGroupsRequest();
+	std::string getAccountId() const;
+	void setAccountId(const std::string &accountId);
+	std::vector<std::string> getResourceGroupIds() const;
+	void setResourceGroupIds(const std::vector<std::string> &resourceGroupIds);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::string accountId_;
+	std::vector<std::string> resourceGroupIds_;
+	std::string nextToken_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTRESOURCEGROUPSREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListMultiAccountResourceGroupsResult.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_RESOURCECENTER_MODEL_LISTMULTIACCOUNTRESOURCEGROUPSRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTRESOURCEGROUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT ListMultiAccountResourceGroupsResult : public ServiceResult
+			{
+			public:
+				struct ResourceGroup
+				{
+					std::string status;
+					std::string accountId;
+					std::string displayName;
+					std::string id;
+					std::string createDate;
+					std::string name;
+				};
+
+
+				ListMultiAccountResourceGroupsResult();
+				explicit ListMultiAccountResourceGroupsResult(const std::string &payload);
+				~ListMultiAccountResourceGroupsResult();
+				std::string getNextToken()const;
+				std::string getDynamicCode()const;
+				std::vector<ResourceGroup> getResourceGroups()const;
+				std::string getDynamicMessage()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string dynamicCode_;
+				std::vector<ResourceGroup> resourceGroups_;
+				std::string dynamicMessage_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTRESOURCEGROUPSRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListMultiAccountTagKeysRequest.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_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGKEYSREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGKEYSREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT ListMultiAccountTagKeysRequest : public RpcServiceRequest {
+public:
+	ListMultiAccountTagKeysRequest();
+	~ListMultiAccountTagKeysRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getScope() const;
+	void setScope(const std::string &scope);
+	std::string getMatchType() const;
+	void setMatchType(const std::string &matchType);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getTagKey() const;
+	void setTagKey(const std::string &tagKey);
+
+private:
+	std::string nextToken_;
+	std::string scope_;
+	std::string matchType_;
+	int maxResults_;
+	std::string tagKey_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGKEYSREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListMultiAccountTagKeysResult.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_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGKEYSRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGKEYSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT ListMultiAccountTagKeysResult : public ServiceResult
+			{
+			public:
+
+
+				ListMultiAccountTagKeysResult();
+				explicit ListMultiAccountTagKeysResult(const std::string &payload);
+				~ListMultiAccountTagKeysResult();
+				std::string getNextToken()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				std::vector<std::string> getTagKeys()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				std::vector<std::string> tagKeys_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGKEYSRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListMultiAccountTagValuesRequest.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_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGVALUESREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGVALUESREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT ListMultiAccountTagValuesRequest : public RpcServiceRequest {
+public:
+	ListMultiAccountTagValuesRequest();
+	~ListMultiAccountTagValuesRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getScope() const;
+	void setScope(const std::string &scope);
+	std::string getMatchType() const;
+	void setMatchType(const std::string &matchType);
+	std::string getTagValue() const;
+	void setTagValue(const std::string &tagValue);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getTagKey() const;
+	void setTagKey(const std::string &tagKey);
+
+private:
+	std::string nextToken_;
+	std::string scope_;
+	std::string matchType_;
+	std::string tagValue_;
+	int maxResults_;
+	std::string tagKey_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGVALUESREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListMultiAccountTagValuesResult.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_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGVALUESRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGVALUESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT ListMultiAccountTagValuesResult : public ServiceResult
+			{
+			public:
+
+
+				ListMultiAccountTagValuesResult();
+				explicit ListMultiAccountTagValuesResult(const std::string &payload);
+				~ListMultiAccountTagValuesResult();
+				std::string getNextToken()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				std::vector<std::string> getTagValues()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				std::vector<std::string> tagValues_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTMULTIACCOUNTTAGVALUESRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListResourceTypesRequest.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_RESOURCECENTER_MODEL_LISTRESOURCETYPESREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTRESOURCETYPESREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT ListResourceTypesRequest : public RpcServiceRequest {
+public:
+	ListResourceTypesRequest();
+	~ListResourceTypesRequest();
+	std::vector<std::string> getQuery() const;
+	void setQuery(const std::vector<std::string> &query);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::vector<std::string> query_;
+	std::string resourceType_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTRESOURCETYPESREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListResourceTypesResult.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_RESOURCECENTER_MODEL_LISTRESOURCETYPESRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTRESOURCETYPESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT ListResourceTypesResult : public ServiceResult
+			{
+			public:
+				struct ResourceType
+				{
+					struct CodeMapping
+					{
+						std::string tag;
+						std::string resourceGroup;
+					};
+					struct Urls
+					{
+						std::string productConsoleUrl;
+						std::string resourceConsoleUrl;
+					};
+					std::string resourceTypeName;
+					std::string productName;
+					std::vector<std::string> filterKeys;
+					CodeMapping codeMapping;
+					std::string resourceType;
+					Urls urls;
+				};
+
+
+				ListResourceTypesResult();
+				explicit ListResourceTypesResult(const std::string &payload);
+				~ListResourceTypesResult();
+				std::vector<ResourceType> getResourceTypes()const;
+				std::string getDynamicCode()const;
+				std::string getErrorCode()const;
+				std::string getDynamicMessage()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ResourceType> resourceTypes_;
+				std::string dynamicCode_;
+				std::string errorCode_;
+				std::string dynamicMessage_;
+				std::string errorMessage_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTRESOURCETYPESRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListTagKeysRequest.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_RESOURCECENTER_MODEL_LISTTAGKEYSREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTTAGKEYSREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT ListTagKeysRequest : public RpcServiceRequest {
+public:
+	ListTagKeysRequest();
+	~ListTagKeysRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getMatchType() const;
+	void setMatchType(const std::string &matchType);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getTagKey() const;
+	void setTagKey(const std::string &tagKey);
+
+private:
+	std::string nextToken_;
+	std::string matchType_;
+	int maxResults_;
+	std::string tagKey_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTTAGKEYSREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListTagKeysResult.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_RESOURCECENTER_MODEL_LISTTAGKEYSRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTTAGKEYSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT ListTagKeysResult : public ServiceResult
+			{
+			public:
+
+
+				ListTagKeysResult();
+				explicit ListTagKeysResult(const std::string &payload);
+				~ListTagKeysResult();
+				std::string getNextToken()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				std::vector<std::string> getTagKeys()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				std::vector<std::string> tagKeys_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTTAGKEYSRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListTagValuesRequest.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_RESOURCECENTER_MODEL_LISTTAGVALUESREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTTAGVALUESREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT ListTagValuesRequest : public RpcServiceRequest {
+public:
+	ListTagValuesRequest();
+	~ListTagValuesRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getMatchType() const;
+	void setMatchType(const std::string &matchType);
+	std::string getTagValue() const;
+	void setTagValue(const std::string &tagValue);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getTagKey() const;
+	void setTagKey(const std::string &tagKey);
+
+private:
+	std::string nextToken_;
+	std::string matchType_;
+	std::string tagValue_;
+	int maxResults_;
+	std::string tagKey_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTTAGVALUESREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/ListTagValuesResult.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_RESOURCECENTER_MODEL_LISTTAGVALUESRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_LISTTAGVALUESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT ListTagValuesResult : public ServiceResult
+			{
+			public:
+
+
+				ListTagValuesResult();
+				explicit ListTagValuesResult(const std::string &payload);
+				~ListTagValuesResult();
+				std::string getNextToken()const;
+				std::string getDynamicCode()const;
+				std::string getDynamicMessage()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				std::vector<std::string> getTagValues()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string dynamicCode_;
+				std::string dynamicMessage_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				std::vector<std::string> tagValues_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_LISTTAGVALUESRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/SearchMultiAccountResourcesRequest.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_RESOURCECENTER_MODEL_SEARCHMULTIACCOUNTRESOURCESREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_SEARCHMULTIACCOUNTRESOURCESREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT SearchMultiAccountResourcesRequest : public RpcServiceRequest {
+public:
+	struct SortCriterion {
+		std::string key;
+		std::string order;
+	};
+	struct Filter {
+		std::string matchType;
+		std::string key;
+	};
+	SearchMultiAccountResourcesRequest();
+	~SearchMultiAccountResourcesRequest();
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getScope() const;
+	void setScope(const std::string &scope);
+	SortCriterion getSortCriterion() const;
+	void setSortCriterion(const SortCriterion &sortCriterion);
+	std::vector<Filter> getFilter() const;
+	void setFilter(const std::vector<Filter> &filter);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::string nextToken_;
+	std::string scope_;
+	SortCriterion sortCriterion_;
+	std::vector<Filter> filter_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_SEARCHMULTIACCOUNTRESOURCESREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/SearchMultiAccountResourcesResult.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RESOURCECENTER_MODEL_SEARCHMULTIACCOUNTRESOURCESRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_SEARCHMULTIACCOUNTRESOURCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT SearchMultiAccountResourcesResult : public ServiceResult
+			{
+			public:
+				struct Filter
+				{
+					std::string matchType;
+					std::vector<std::string> values;
+					std::string key;
+				};
+				struct Resource
+				{
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
+					std::vector<std::string> ipAddresses;
+					std::string accountId;
+					std::string resourceGroupId;
+					std::string zoneId;
+					std::string resourceId;
+					std::string resourceName;
+					std::string createTime;
+					std::string resourceType;
+					std::string regionId;
+					std::vector<Resource::Tag> tags;
+				};
+
+
+				SearchMultiAccountResourcesResult();
+				explicit SearchMultiAccountResourcesResult(const std::string &payload);
+				~SearchMultiAccountResourcesResult();
+				std::vector<Filter> getFilters()const;
+				std::string getNextToken()const;
+				std::string getScope()const;
+				int getMaxResults()const;
+				std::vector<Resource> getResources()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Filter> filters_;
+				std::string nextToken_;
+				std::string scope_;
+				int maxResults_;
+				std::vector<Resource> resources_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_SEARCHMULTIACCOUNTRESOURCESRESULT_H_

resourcecenter/include/alibabacloud/resourcecenter/model/SearchResourcesRequest.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_RESOURCECENTER_MODEL_SEARCHRESOURCESREQUEST_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_SEARCHRESOURCESREQUEST_H_
+
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace ResourceCenter {
+namespace Model {
+class ALIBABACLOUD_RESOURCECENTER_EXPORT SearchResourcesRequest : public RpcServiceRequest {
+public:
+	struct SortCriterion {
+		std::string key;
+		std::string order;
+	};
+	struct Filter {
+		std::string matchType;
+		std::string key;
+	};
+	SearchResourcesRequest();
+	~SearchResourcesRequest();
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	SortCriterion getSortCriterion() const;
+	void setSortCriterion(const SortCriterion &sortCriterion);
+	std::vector<Filter> getFilter() const;
+	void setFilter(const std::vector<Filter> &filter);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::string resourceGroupId_;
+	std::string nextToken_;
+	SortCriterion sortCriterion_;
+	std::vector<Filter> filter_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace ResourceCenter
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_SEARCHRESOURCESREQUEST_H_

resourcecenter/include/alibabacloud/resourcecenter/model/SearchResourcesResult.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_RESOURCECENTER_MODEL_SEARCHRESOURCESRESULT_H_
+#define ALIBABACLOUD_RESOURCECENTER_MODEL_SEARCHRESOURCESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/resourcecenter/ResourceCenterExport.h>
+
+namespace AlibabaCloud
+{
+	namespace ResourceCenter
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RESOURCECENTER_EXPORT SearchResourcesResult : public ServiceResult
+			{
+			public:
+				struct Filter
+				{
+					std::string matchType;
+					std::vector<std::string> values;
+					std::string key;
+				};
+				struct Resource
+				{
+					struct Tag
+					{
+						std::string value;
+						std::string key;
+					};
+					std::vector<std::string> ipAddresses;
+					std::string accountId;
+					std::string resourceGroupId;
+					std::string zoneId;
+					std::string resourceId;
+					std::string resourceName;
+					std::string createTime;
+					std::string resourceType;
+					std::string regionId;
+					std::vector<Resource::Tag> tags;
+				};
+
+
+				SearchResourcesResult();
+				explicit SearchResourcesResult(const std::string &payload);
+				~SearchResourcesResult();
+				std::vector<Filter> getFilters()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				std::vector<Resource> getResources()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Filter> filters_;
+				std::string nextToken_;
+				int maxResults_;
+				std::vector<Resource> resources_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RESOURCECENTER_MODEL_SEARCHRESOURCESRESULT_H_

resourcecenter/src/ResourceCenterClient.cc

@@ -0,0 +1,629 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/resourcecenter/ResourceCenterClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::ResourceCenter;
+using namespace AlibabaCloud::ResourceCenter::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "ResourceCenter";
+}
+
+ResourceCenterClient::ResourceCenterClient(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, "");
+}
+
+ResourceCenterClient::ResourceCenterClient(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, "");
+}
+
+ResourceCenterClient::ResourceCenterClient(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, "");
+}
+
+ResourceCenterClient::~ResourceCenterClient()
+{}
+
+ResourceCenterClient::DisableMultiAccountResourceCenterOutcome ResourceCenterClient::disableMultiAccountResourceCenter(const DisableMultiAccountResourceCenterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableMultiAccountResourceCenterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableMultiAccountResourceCenterOutcome(DisableMultiAccountResourceCenterResult(outcome.result()));
+	else
+		return DisableMultiAccountResourceCenterOutcome(outcome.error());
+}
+
+void ResourceCenterClient::disableMultiAccountResourceCenterAsync(const DisableMultiAccountResourceCenterRequest& request, const DisableMultiAccountResourceCenterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableMultiAccountResourceCenter(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::DisableMultiAccountResourceCenterOutcomeCallable ResourceCenterClient::disableMultiAccountResourceCenterCallable(const DisableMultiAccountResourceCenterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableMultiAccountResourceCenterOutcome()>>(
+			[this, request]()
+			{
+			return this->disableMultiAccountResourceCenter(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::DisableResourceCenterOutcome ResourceCenterClient::disableResourceCenter(const DisableResourceCenterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DisableResourceCenterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DisableResourceCenterOutcome(DisableResourceCenterResult(outcome.result()));
+	else
+		return DisableResourceCenterOutcome(outcome.error());
+}
+
+void ResourceCenterClient::disableResourceCenterAsync(const DisableResourceCenterRequest& request, const DisableResourceCenterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, disableResourceCenter(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::DisableResourceCenterOutcomeCallable ResourceCenterClient::disableResourceCenterCallable(const DisableResourceCenterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DisableResourceCenterOutcome()>>(
+			[this, request]()
+			{
+			return this->disableResourceCenter(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::EnableMultiAccountResourceCenterOutcome ResourceCenterClient::enableMultiAccountResourceCenter(const EnableMultiAccountResourceCenterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableMultiAccountResourceCenterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableMultiAccountResourceCenterOutcome(EnableMultiAccountResourceCenterResult(outcome.result()));
+	else
+		return EnableMultiAccountResourceCenterOutcome(outcome.error());
+}
+
+void ResourceCenterClient::enableMultiAccountResourceCenterAsync(const EnableMultiAccountResourceCenterRequest& request, const EnableMultiAccountResourceCenterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableMultiAccountResourceCenter(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::EnableMultiAccountResourceCenterOutcomeCallable ResourceCenterClient::enableMultiAccountResourceCenterCallable(const EnableMultiAccountResourceCenterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableMultiAccountResourceCenterOutcome()>>(
+			[this, request]()
+			{
+			return this->enableMultiAccountResourceCenter(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::EnableResourceCenterOutcome ResourceCenterClient::enableResourceCenter(const EnableResourceCenterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return EnableResourceCenterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EnableResourceCenterOutcome(EnableResourceCenterResult(outcome.result()));
+	else
+		return EnableResourceCenterOutcome(outcome.error());
+}
+
+void ResourceCenterClient::enableResourceCenterAsync(const EnableResourceCenterRequest& request, const EnableResourceCenterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, enableResourceCenter(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::EnableResourceCenterOutcomeCallable ResourceCenterClient::enableResourceCenterCallable(const EnableResourceCenterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EnableResourceCenterOutcome()>>(
+			[this, request]()
+			{
+			return this->enableResourceCenter(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::GetMultiAccountResourceCenterServiceStatusOutcome ResourceCenterClient::getMultiAccountResourceCenterServiceStatus(const GetMultiAccountResourceCenterServiceStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetMultiAccountResourceCenterServiceStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetMultiAccountResourceCenterServiceStatusOutcome(GetMultiAccountResourceCenterServiceStatusResult(outcome.result()));
+	else
+		return GetMultiAccountResourceCenterServiceStatusOutcome(outcome.error());
+}
+
+void ResourceCenterClient::getMultiAccountResourceCenterServiceStatusAsync(const GetMultiAccountResourceCenterServiceStatusRequest& request, const GetMultiAccountResourceCenterServiceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getMultiAccountResourceCenterServiceStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::GetMultiAccountResourceCenterServiceStatusOutcomeCallable ResourceCenterClient::getMultiAccountResourceCenterServiceStatusCallable(const GetMultiAccountResourceCenterServiceStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetMultiAccountResourceCenterServiceStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->getMultiAccountResourceCenterServiceStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::GetMultiAccountResourceConfigurationOutcome ResourceCenterClient::getMultiAccountResourceConfiguration(const GetMultiAccountResourceConfigurationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetMultiAccountResourceConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetMultiAccountResourceConfigurationOutcome(GetMultiAccountResourceConfigurationResult(outcome.result()));
+	else
+		return GetMultiAccountResourceConfigurationOutcome(outcome.error());
+}
+
+void ResourceCenterClient::getMultiAccountResourceConfigurationAsync(const GetMultiAccountResourceConfigurationRequest& request, const GetMultiAccountResourceConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getMultiAccountResourceConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::GetMultiAccountResourceConfigurationOutcomeCallable ResourceCenterClient::getMultiAccountResourceConfigurationCallable(const GetMultiAccountResourceConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetMultiAccountResourceConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->getMultiAccountResourceConfiguration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::GetResourceCenterServiceStatusOutcome ResourceCenterClient::getResourceCenterServiceStatus(const GetResourceCenterServiceStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetResourceCenterServiceStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetResourceCenterServiceStatusOutcome(GetResourceCenterServiceStatusResult(outcome.result()));
+	else
+		return GetResourceCenterServiceStatusOutcome(outcome.error());
+}
+
+void ResourceCenterClient::getResourceCenterServiceStatusAsync(const GetResourceCenterServiceStatusRequest& request, const GetResourceCenterServiceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getResourceCenterServiceStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::GetResourceCenterServiceStatusOutcomeCallable ResourceCenterClient::getResourceCenterServiceStatusCallable(const GetResourceCenterServiceStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetResourceCenterServiceStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->getResourceCenterServiceStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::GetResourceConfigurationOutcome ResourceCenterClient::getResourceConfiguration(const GetResourceConfigurationRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetResourceConfigurationOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetResourceConfigurationOutcome(GetResourceConfigurationResult(outcome.result()));
+	else
+		return GetResourceConfigurationOutcome(outcome.error());
+}
+
+void ResourceCenterClient::getResourceConfigurationAsync(const GetResourceConfigurationRequest& request, const GetResourceConfigurationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getResourceConfiguration(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::GetResourceConfigurationOutcomeCallable ResourceCenterClient::getResourceConfigurationCallable(const GetResourceConfigurationRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetResourceConfigurationOutcome()>>(
+			[this, request]()
+			{
+			return this->getResourceConfiguration(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::ListMultiAccountResourceGroupsOutcome ResourceCenterClient::listMultiAccountResourceGroups(const ListMultiAccountResourceGroupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListMultiAccountResourceGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListMultiAccountResourceGroupsOutcome(ListMultiAccountResourceGroupsResult(outcome.result()));
+	else
+		return ListMultiAccountResourceGroupsOutcome(outcome.error());
+}
+
+void ResourceCenterClient::listMultiAccountResourceGroupsAsync(const ListMultiAccountResourceGroupsRequest& request, const ListMultiAccountResourceGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listMultiAccountResourceGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::ListMultiAccountResourceGroupsOutcomeCallable ResourceCenterClient::listMultiAccountResourceGroupsCallable(const ListMultiAccountResourceGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListMultiAccountResourceGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->listMultiAccountResourceGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::ListMultiAccountTagKeysOutcome ResourceCenterClient::listMultiAccountTagKeys(const ListMultiAccountTagKeysRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListMultiAccountTagKeysOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListMultiAccountTagKeysOutcome(ListMultiAccountTagKeysResult(outcome.result()));
+	else
+		return ListMultiAccountTagKeysOutcome(outcome.error());
+}
+
+void ResourceCenterClient::listMultiAccountTagKeysAsync(const ListMultiAccountTagKeysRequest& request, const ListMultiAccountTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listMultiAccountTagKeys(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::ListMultiAccountTagKeysOutcomeCallable ResourceCenterClient::listMultiAccountTagKeysCallable(const ListMultiAccountTagKeysRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListMultiAccountTagKeysOutcome()>>(
+			[this, request]()
+			{
+			return this->listMultiAccountTagKeys(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::ListMultiAccountTagValuesOutcome ResourceCenterClient::listMultiAccountTagValues(const ListMultiAccountTagValuesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListMultiAccountTagValuesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListMultiAccountTagValuesOutcome(ListMultiAccountTagValuesResult(outcome.result()));
+	else
+		return ListMultiAccountTagValuesOutcome(outcome.error());
+}
+
+void ResourceCenterClient::listMultiAccountTagValuesAsync(const ListMultiAccountTagValuesRequest& request, const ListMultiAccountTagValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listMultiAccountTagValues(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::ListMultiAccountTagValuesOutcomeCallable ResourceCenterClient::listMultiAccountTagValuesCallable(const ListMultiAccountTagValuesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListMultiAccountTagValuesOutcome()>>(
+			[this, request]()
+			{
+			return this->listMultiAccountTagValues(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::ListResourceTypesOutcome ResourceCenterClient::listResourceTypes(const ListResourceTypesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListResourceTypesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListResourceTypesOutcome(ListResourceTypesResult(outcome.result()));
+	else
+		return ListResourceTypesOutcome(outcome.error());
+}
+
+void ResourceCenterClient::listResourceTypesAsync(const ListResourceTypesRequest& request, const ListResourceTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listResourceTypes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::ListResourceTypesOutcomeCallable ResourceCenterClient::listResourceTypesCallable(const ListResourceTypesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListResourceTypesOutcome()>>(
+			[this, request]()
+			{
+			return this->listResourceTypes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::ListTagKeysOutcome ResourceCenterClient::listTagKeys(const ListTagKeysRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTagKeysOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTagKeysOutcome(ListTagKeysResult(outcome.result()));
+	else
+		return ListTagKeysOutcome(outcome.error());
+}
+
+void ResourceCenterClient::listTagKeysAsync(const ListTagKeysRequest& request, const ListTagKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTagKeys(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::ListTagKeysOutcomeCallable ResourceCenterClient::listTagKeysCallable(const ListTagKeysRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTagKeysOutcome()>>(
+			[this, request]()
+			{
+			return this->listTagKeys(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::ListTagValuesOutcome ResourceCenterClient::listTagValues(const ListTagValuesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListTagValuesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListTagValuesOutcome(ListTagValuesResult(outcome.result()));
+	else
+		return ListTagValuesOutcome(outcome.error());
+}
+
+void ResourceCenterClient::listTagValuesAsync(const ListTagValuesRequest& request, const ListTagValuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listTagValues(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::ListTagValuesOutcomeCallable ResourceCenterClient::listTagValuesCallable(const ListTagValuesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListTagValuesOutcome()>>(
+			[this, request]()
+			{
+			return this->listTagValues(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::SearchMultiAccountResourcesOutcome ResourceCenterClient::searchMultiAccountResources(const SearchMultiAccountResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SearchMultiAccountResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SearchMultiAccountResourcesOutcome(SearchMultiAccountResourcesResult(outcome.result()));
+	else
+		return SearchMultiAccountResourcesOutcome(outcome.error());
+}
+
+void ResourceCenterClient::searchMultiAccountResourcesAsync(const SearchMultiAccountResourcesRequest& request, const SearchMultiAccountResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, searchMultiAccountResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::SearchMultiAccountResourcesOutcomeCallable ResourceCenterClient::searchMultiAccountResourcesCallable(const SearchMultiAccountResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SearchMultiAccountResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->searchMultiAccountResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ResourceCenterClient::SearchResourcesOutcome ResourceCenterClient::searchResources(const SearchResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SearchResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SearchResourcesOutcome(SearchResourcesResult(outcome.result()));
+	else
+		return SearchResourcesOutcome(outcome.error());
+}
+
+void ResourceCenterClient::searchResourcesAsync(const SearchResourcesRequest& request, const SearchResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, searchResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ResourceCenterClient::SearchResourcesOutcomeCallable ResourceCenterClient::searchResourcesCallable(const SearchResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SearchResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->searchResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

resourcecenter/src/model/DisableMultiAccountResourceCenterRequest.cc

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/DisableMultiAccountResourceCenterRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::DisableMultiAccountResourceCenterRequest;
+
+DisableMultiAccountResourceCenterRequest::DisableMultiAccountResourceCenterRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "DisableMultiAccountResourceCenter") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DisableMultiAccountResourceCenterRequest::~DisableMultiAccountResourceCenterRequest() {}
+

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

resourcecenter/src/model/DisableResourceCenterRequest.cc

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/DisableResourceCenterRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::DisableResourceCenterRequest;
+
+DisableResourceCenterRequest::DisableResourceCenterRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "DisableResourceCenter") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DisableResourceCenterRequest::~DisableResourceCenterRequest() {}
+

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

resourcecenter/src/model/EnableMultiAccountResourceCenterRequest.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/resourcecenter/model/EnableMultiAccountResourceCenterRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::EnableMultiAccountResourceCenterRequest;
+
+EnableMultiAccountResourceCenterRequest::EnableMultiAccountResourceCenterRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "EnableMultiAccountResourceCenter") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+EnableMultiAccountResourceCenterRequest::~EnableMultiAccountResourceCenterRequest() {}
+
+std::string EnableMultiAccountResourceCenterRequest::getChannel() const {
+  return channel_;
+}
+
+void EnableMultiAccountResourceCenterRequest::setChannel(const std::string &channel) {
+  channel_ = channel;
+  setParameter(std::string("Channel"), channel);
+}
+

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

resourcecenter/src/model/EnableResourceCenterRequest.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/resourcecenter/model/EnableResourceCenterRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::EnableResourceCenterRequest;
+
+EnableResourceCenterRequest::EnableResourceCenterRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "EnableResourceCenter") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+EnableResourceCenterRequest::~EnableResourceCenterRequest() {}
+
+std::string EnableResourceCenterRequest::getChannel() const {
+  return channel_;
+}
+
+void EnableResourceCenterRequest::setChannel(const std::string &channel) {
+  channel_ = channel;
+  setParameter(std::string("Channel"), channel);
+}
+

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

resourcecenter/src/model/GetMultiAccountResourceCenterServiceStatusRequest.cc

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/GetMultiAccountResourceCenterServiceStatusRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::GetMultiAccountResourceCenterServiceStatusRequest;
+
+GetMultiAccountResourceCenterServiceStatusRequest::GetMultiAccountResourceCenterServiceStatusRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "GetMultiAccountResourceCenterServiceStatus") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetMultiAccountResourceCenterServiceStatusRequest::~GetMultiAccountResourceCenterServiceStatusRequest() {}
+

resourcecenter/src/model/GetMultiAccountResourceCenterServiceStatusResult.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/resourcecenter/model/GetMultiAccountResourceCenterServiceStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceCenter;
+using namespace AlibabaCloud::ResourceCenter::Model;
+
+GetMultiAccountResourceCenterServiceStatusResult::GetMultiAccountResourceCenterServiceStatusResult() :
+	ServiceResult()
+{}
+
+GetMultiAccountResourceCenterServiceStatusResult::GetMultiAccountResourceCenterServiceStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetMultiAccountResourceCenterServiceStatusResult::~GetMultiAccountResourceCenterServiceStatusResult()
+{}
+
+void GetMultiAccountResourceCenterServiceStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ServiceStatus"].isNull())
+		serviceStatus_ = value["ServiceStatus"].asString();
+	if(!value["InitialStatus"].isNull())
+		initialStatus_ = value["InitialStatus"].asString();
+
+}
+
+std::string GetMultiAccountResourceCenterServiceStatusResult::getServiceStatus()const
+{
+	return serviceStatus_;
+}
+
+std::string GetMultiAccountResourceCenterServiceStatusResult::getInitialStatus()const
+{
+	return initialStatus_;
+}
+

resourcecenter/src/model/GetMultiAccountResourceConfigurationRequest.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/resourcecenter/model/GetMultiAccountResourceConfigurationRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::GetMultiAccountResourceConfigurationRequest;
+
+GetMultiAccountResourceConfigurationRequest::GetMultiAccountResourceConfigurationRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "GetMultiAccountResourceConfiguration") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetMultiAccountResourceConfigurationRequest::~GetMultiAccountResourceConfigurationRequest() {}
+
+std::string GetMultiAccountResourceConfigurationRequest::getResourceId() const {
+  return resourceId_;
+}
+
+void GetMultiAccountResourceConfigurationRequest::setResourceId(const std::string &resourceId) {
+  resourceId_ = resourceId;
+  setParameter(std::string("ResourceId"), resourceId);
+}
+
+std::string GetMultiAccountResourceConfigurationRequest::getResourceType() const {
+  return resourceType_;
+}
+
+void GetMultiAccountResourceConfigurationRequest::setResourceType(const std::string &resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), resourceType);
+}
+
+std::string GetMultiAccountResourceConfigurationRequest::getAccountId() const {
+  return accountId_;
+}
+
+void GetMultiAccountResourceConfigurationRequest::setAccountId(const std::string &accountId) {
+  accountId_ = accountId;
+  setParameter(std::string("AccountId"), accountId);
+}
+
+std::string GetMultiAccountResourceConfigurationRequest::getResourceRegionId() const {
+  return resourceRegionId_;
+}
+
+void GetMultiAccountResourceConfigurationRequest::setResourceRegionId(const std::string &resourceRegionId) {
+  resourceRegionId_ = resourceRegionId;
+  setParameter(std::string("ResourceRegionId"), resourceRegionId);
+}
+

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

resourcecenter/src/model/GetResourceCenterServiceStatusRequest.cc

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/GetResourceCenterServiceStatusRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::GetResourceCenterServiceStatusRequest;
+
+GetResourceCenterServiceStatusRequest::GetResourceCenterServiceStatusRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "GetResourceCenterServiceStatus") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetResourceCenterServiceStatusRequest::~GetResourceCenterServiceStatusRequest() {}
+

resourcecenter/src/model/GetResourceCenterServiceStatusResult.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/resourcecenter/model/GetResourceCenterServiceStatusResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceCenter;
+using namespace AlibabaCloud::ResourceCenter::Model;
+
+GetResourceCenterServiceStatusResult::GetResourceCenterServiceStatusResult() :
+	ServiceResult()
+{}
+
+GetResourceCenterServiceStatusResult::GetResourceCenterServiceStatusResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetResourceCenterServiceStatusResult::~GetResourceCenterServiceStatusResult()
+{}
+
+void GetResourceCenterServiceStatusResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["ServiceStatus"].isNull())
+		serviceStatus_ = value["ServiceStatus"].asString();
+	if(!value["InitialStatus"].isNull())
+		initialStatus_ = value["InitialStatus"].asString();
+
+}
+
+std::string GetResourceCenterServiceStatusResult::getServiceStatus()const
+{
+	return serviceStatus_;
+}
+
+std::string GetResourceCenterServiceStatusResult::getInitialStatus()const
+{
+	return initialStatus_;
+}
+

resourcecenter/src/model/GetResourceConfigurationRequest.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/resourcecenter/model/GetResourceConfigurationRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::GetResourceConfigurationRequest;
+
+GetResourceConfigurationRequest::GetResourceConfigurationRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "GetResourceConfiguration") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetResourceConfigurationRequest::~GetResourceConfigurationRequest() {}
+
+std::string GetResourceConfigurationRequest::getResourceId() const {
+  return resourceId_;
+}
+
+void GetResourceConfigurationRequest::setResourceId(const std::string &resourceId) {
+  resourceId_ = resourceId;
+  setParameter(std::string("ResourceId"), resourceId);
+}
+
+std::string GetResourceConfigurationRequest::getResourceType() const {
+  return resourceType_;
+}
+
+void GetResourceConfigurationRequest::setResourceType(const std::string &resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), resourceType);
+}
+
+std::string GetResourceConfigurationRequest::getResourceRegionId() const {
+  return resourceRegionId_;
+}
+
+void GetResourceConfigurationRequest::setResourceRegionId(const std::string &resourceRegionId) {
+  resourceRegionId_ = resourceRegionId;
+  setParameter(std::string("ResourceRegionId"), resourceRegionId);
+}
+

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

resourcecenter/src/model/ListMultiAccountResourceGroupsRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/resourcecenter/model/ListMultiAccountResourceGroupsRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::ListMultiAccountResourceGroupsRequest;
+
+ListMultiAccountResourceGroupsRequest::ListMultiAccountResourceGroupsRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "ListMultiAccountResourceGroups") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListMultiAccountResourceGroupsRequest::~ListMultiAccountResourceGroupsRequest() {}
+
+std::string ListMultiAccountResourceGroupsRequest::getAccountId() const {
+  return accountId_;
+}
+
+void ListMultiAccountResourceGroupsRequest::setAccountId(const std::string &accountId) {
+  accountId_ = accountId;
+  setParameter(std::string("AccountId"), accountId);
+}
+
+std::vector<std::string> ListMultiAccountResourceGroupsRequest::getResourceGroupIds() const {
+  return resourceGroupIds_;
+}
+
+void ListMultiAccountResourceGroupsRequest::setResourceGroupIds(const std::vector<std::string> &resourceGroupIds) {
+  resourceGroupIds_ = resourceGroupIds;
+}
+
+std::string ListMultiAccountResourceGroupsRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListMultiAccountResourceGroupsRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+int ListMultiAccountResourceGroupsRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListMultiAccountResourceGroupsRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+

resourcecenter/src/model/ListMultiAccountResourceGroupsResult.cc

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/ListMultiAccountResourceGroupsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceCenter;
+using namespace AlibabaCloud::ResourceCenter::Model;
+
+ListMultiAccountResourceGroupsResult::ListMultiAccountResourceGroupsResult() :
+	ServiceResult()
+{}
+
+ListMultiAccountResourceGroupsResult::ListMultiAccountResourceGroupsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListMultiAccountResourceGroupsResult::~ListMultiAccountResourceGroupsResult()
+{}
+
+void ListMultiAccountResourceGroupsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResourceGroupsNode = value["ResourceGroups"]["ResourceGroup"];
+	for (auto valueResourceGroupsResourceGroup : allResourceGroupsNode)
+	{
+		ResourceGroup resourceGroupsObject;
+		if(!valueResourceGroupsResourceGroup["DisplayName"].isNull())
+			resourceGroupsObject.displayName = valueResourceGroupsResourceGroup["DisplayName"].asString();
+		if(!valueResourceGroupsResourceGroup["Status"].isNull())
+			resourceGroupsObject.status = valueResourceGroupsResourceGroup["Status"].asString();
+		if(!valueResourceGroupsResourceGroup["AccountId"].isNull())
+			resourceGroupsObject.accountId = valueResourceGroupsResourceGroup["AccountId"].asString();
+		if(!valueResourceGroupsResourceGroup["Name"].isNull())
+			resourceGroupsObject.name = valueResourceGroupsResourceGroup["Name"].asString();
+		if(!valueResourceGroupsResourceGroup["CreateDate"].isNull())
+			resourceGroupsObject.createDate = valueResourceGroupsResourceGroup["CreateDate"].asString();
+		if(!valueResourceGroupsResourceGroup["Id"].isNull())
+			resourceGroupsObject.id = valueResourceGroupsResourceGroup["Id"].asString();
+		resourceGroups_.push_back(resourceGroupsObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+
+}
+
+std::string ListMultiAccountResourceGroupsResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListMultiAccountResourceGroupsResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::vector<ListMultiAccountResourceGroupsResult::ResourceGroup> ListMultiAccountResourceGroupsResult::getResourceGroups()const
+{
+	return resourceGroups_;
+}
+
+std::string ListMultiAccountResourceGroupsResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string ListMultiAccountResourceGroupsResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListMultiAccountResourceGroupsResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool ListMultiAccountResourceGroupsResult::getSuccess()const
+{
+	return success_;
+}
+

resourcecenter/src/model/ListMultiAccountTagKeysRequest.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/resourcecenter/model/ListMultiAccountTagKeysRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::ListMultiAccountTagKeysRequest;
+
+ListMultiAccountTagKeysRequest::ListMultiAccountTagKeysRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "ListMultiAccountTagKeys") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListMultiAccountTagKeysRequest::~ListMultiAccountTagKeysRequest() {}
+
+std::string ListMultiAccountTagKeysRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListMultiAccountTagKeysRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListMultiAccountTagKeysRequest::getScope() const {
+  return scope_;
+}
+
+void ListMultiAccountTagKeysRequest::setScope(const std::string &scope) {
+  scope_ = scope;
+  setParameter(std::string("Scope"), scope);
+}
+
+std::string ListMultiAccountTagKeysRequest::getMatchType() const {
+  return matchType_;
+}
+
+void ListMultiAccountTagKeysRequest::setMatchType(const std::string &matchType) {
+  matchType_ = matchType;
+  setParameter(std::string("MatchType"), matchType);
+}
+
+int ListMultiAccountTagKeysRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListMultiAccountTagKeysRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string ListMultiAccountTagKeysRequest::getTagKey() const {
+  return tagKey_;
+}
+
+void ListMultiAccountTagKeysRequest::setTagKey(const std::string &tagKey) {
+  tagKey_ = tagKey;
+  setParameter(std::string("TagKey"), tagKey);
+}
+

resourcecenter/src/model/ListMultiAccountTagKeysResult.cc

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/ListMultiAccountTagKeysResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceCenter;
+using namespace AlibabaCloud::ResourceCenter::Model;
+
+ListMultiAccountTagKeysResult::ListMultiAccountTagKeysResult() :
+	ServiceResult()
+{}
+
+ListMultiAccountTagKeysResult::ListMultiAccountTagKeysResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListMultiAccountTagKeysResult::~ListMultiAccountTagKeysResult()
+{}
+
+void ListMultiAccountTagKeysResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagKeys = value["TagKeys"]["TagKey"];
+	for (const auto &item : allTagKeys)
+		tagKeys_.push_back(item.asString());
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+
+}
+
+std::string ListMultiAccountTagKeysResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListMultiAccountTagKeysResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string ListMultiAccountTagKeysResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string ListMultiAccountTagKeysResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListMultiAccountTagKeysResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+std::vector<std::string> ListMultiAccountTagKeysResult::getTagKeys()const
+{
+	return tagKeys_;
+}
+
+bool ListMultiAccountTagKeysResult::getSuccess()const
+{
+	return success_;
+}
+

resourcecenter/src/model/ListMultiAccountTagValuesRequest.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/resourcecenter/model/ListMultiAccountTagValuesRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::ListMultiAccountTagValuesRequest;
+
+ListMultiAccountTagValuesRequest::ListMultiAccountTagValuesRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "ListMultiAccountTagValues") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListMultiAccountTagValuesRequest::~ListMultiAccountTagValuesRequest() {}
+
+std::string ListMultiAccountTagValuesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListMultiAccountTagValuesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListMultiAccountTagValuesRequest::getScope() const {
+  return scope_;
+}
+
+void ListMultiAccountTagValuesRequest::setScope(const std::string &scope) {
+  scope_ = scope;
+  setParameter(std::string("Scope"), scope);
+}
+
+std::string ListMultiAccountTagValuesRequest::getMatchType() const {
+  return matchType_;
+}
+
+void ListMultiAccountTagValuesRequest::setMatchType(const std::string &matchType) {
+  matchType_ = matchType;
+  setParameter(std::string("MatchType"), matchType);
+}
+
+std::string ListMultiAccountTagValuesRequest::getTagValue() const {
+  return tagValue_;
+}
+
+void ListMultiAccountTagValuesRequest::setTagValue(const std::string &tagValue) {
+  tagValue_ = tagValue;
+  setParameter(std::string("TagValue"), tagValue);
+}
+
+int ListMultiAccountTagValuesRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListMultiAccountTagValuesRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string ListMultiAccountTagValuesRequest::getTagKey() const {
+  return tagKey_;
+}
+
+void ListMultiAccountTagValuesRequest::setTagKey(const std::string &tagKey) {
+  tagKey_ = tagKey;
+  setParameter(std::string("TagKey"), tagKey);
+}
+

resourcecenter/src/model/ListMultiAccountTagValuesResult.cc

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/ListMultiAccountTagValuesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceCenter;
+using namespace AlibabaCloud::ResourceCenter::Model;
+
+ListMultiAccountTagValuesResult::ListMultiAccountTagValuesResult() :
+	ServiceResult()
+{}
+
+ListMultiAccountTagValuesResult::ListMultiAccountTagValuesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListMultiAccountTagValuesResult::~ListMultiAccountTagValuesResult()
+{}
+
+void ListMultiAccountTagValuesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagValues = value["TagValues"]["TagValue"];
+	for (const auto &item : allTagValues)
+		tagValues_.push_back(item.asString());
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+
+}
+
+std::string ListMultiAccountTagValuesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListMultiAccountTagValuesResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string ListMultiAccountTagValuesResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string ListMultiAccountTagValuesResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListMultiAccountTagValuesResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+std::vector<std::string> ListMultiAccountTagValuesResult::getTagValues()const
+{
+	return tagValues_;
+}
+
+bool ListMultiAccountTagValuesResult::getSuccess()const
+{
+	return success_;
+}
+

resourcecenter/src/model/ListResourceTypesRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/resourcecenter/model/ListResourceTypesRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::ListResourceTypesRequest;
+
+ListResourceTypesRequest::ListResourceTypesRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "ListResourceTypes") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListResourceTypesRequest::~ListResourceTypesRequest() {}
+
+std::vector<std::string> ListResourceTypesRequest::getQuery() const {
+  return query_;
+}
+
+void ListResourceTypesRequest::setQuery(const std::vector<std::string> &query) {
+  query_ = query;
+}
+
+std::string ListResourceTypesRequest::getResourceType() const {
+  return resourceType_;
+}
+
+void ListResourceTypesRequest::setResourceType(const std::string &resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), resourceType);
+}
+
+std::string ListResourceTypesRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void ListResourceTypesRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

resourcecenter/src/model/ListResourceTypesResult.cc

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/ListResourceTypesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceCenter;
+using namespace AlibabaCloud::ResourceCenter::Model;
+
+ListResourceTypesResult::ListResourceTypesResult() :
+	ServiceResult()
+{}
+
+ListResourceTypesResult::ListResourceTypesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListResourceTypesResult::~ListResourceTypesResult()
+{}
+
+void ListResourceTypesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResourceTypesNode = value["ResourceTypes"]["ResourceType"];
+	for (auto valueResourceTypesResourceType : allResourceTypesNode)
+	{
+		ResourceType resourceTypesObject;
+		if(!valueResourceTypesResourceType["ResourceType"].isNull())
+			resourceTypesObject.resourceType = valueResourceTypesResourceType["ResourceType"].asString();
+		if(!valueResourceTypesResourceType["ProductName"].isNull())
+			resourceTypesObject.productName = valueResourceTypesResourceType["ProductName"].asString();
+		if(!valueResourceTypesResourceType["ResourceTypeName"].isNull())
+			resourceTypesObject.resourceTypeName = valueResourceTypesResourceType["ResourceTypeName"].asString();
+		auto codeMappingNode = value["CodeMapping"];
+		if(!codeMappingNode["ResourceGroup"].isNull())
+			resourceTypesObject.codeMapping.resourceGroup = codeMappingNode["ResourceGroup"].asString();
+		if(!codeMappingNode["Tag"].isNull())
+			resourceTypesObject.codeMapping.tag = codeMappingNode["Tag"].asString();
+		auto urlsNode = value["Urls"];
+		if(!urlsNode["ProductConsoleUrl"].isNull())
+			resourceTypesObject.urls.productConsoleUrl = urlsNode["ProductConsoleUrl"].asString();
+		if(!urlsNode["ResourceConsoleUrl"].isNull())
+			resourceTypesObject.urls.resourceConsoleUrl = urlsNode["ResourceConsoleUrl"].asString();
+		auto allFilterKeys = value["FilterKeys"]["FilterKey"];
+		for (auto value : allFilterKeys)
+			resourceTypesObject.filterKeys.push_back(value.asString());
+		resourceTypes_.push_back(resourceTypesObject);
+	}
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+
+}
+
+std::vector<ListResourceTypesResult::ResourceType> ListResourceTypesResult::getResourceTypes()const
+{
+	return resourceTypes_;
+}
+
+std::string ListResourceTypesResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string ListResourceTypesResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListResourceTypesResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string ListResourceTypesResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool ListResourceTypesResult::getSuccess()const
+{
+	return success_;
+}
+

resourcecenter/src/model/ListTagKeysRequest.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/resourcecenter/model/ListTagKeysRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::ListTagKeysRequest;
+
+ListTagKeysRequest::ListTagKeysRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "ListTagKeys") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListTagKeysRequest::~ListTagKeysRequest() {}
+
+std::string ListTagKeysRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListTagKeysRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListTagKeysRequest::getMatchType() const {
+  return matchType_;
+}
+
+void ListTagKeysRequest::setMatchType(const std::string &matchType) {
+  matchType_ = matchType;
+  setParameter(std::string("MatchType"), matchType);
+}
+
+int ListTagKeysRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListTagKeysRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string ListTagKeysRequest::getTagKey() const {
+  return tagKey_;
+}
+
+void ListTagKeysRequest::setTagKey(const std::string &tagKey) {
+  tagKey_ = tagKey;
+  setParameter(std::string("TagKey"), tagKey);
+}
+

resourcecenter/src/model/ListTagKeysResult.cc

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/ListTagKeysResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceCenter;
+using namespace AlibabaCloud::ResourceCenter::Model;
+
+ListTagKeysResult::ListTagKeysResult() :
+	ServiceResult()
+{}
+
+ListTagKeysResult::ListTagKeysResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListTagKeysResult::~ListTagKeysResult()
+{}
+
+void ListTagKeysResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagKeys = value["TagKeys"]["TagKey"];
+	for (const auto &item : allTagKeys)
+		tagKeys_.push_back(item.asString());
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+
+}
+
+std::string ListTagKeysResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListTagKeysResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string ListTagKeysResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string ListTagKeysResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListTagKeysResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+std::vector<std::string> ListTagKeysResult::getTagKeys()const
+{
+	return tagKeys_;
+}
+
+bool ListTagKeysResult::getSuccess()const
+{
+	return success_;
+}
+

resourcecenter/src/model/ListTagValuesRequest.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/resourcecenter/model/ListTagValuesRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::ListTagValuesRequest;
+
+ListTagValuesRequest::ListTagValuesRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "ListTagValues") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListTagValuesRequest::~ListTagValuesRequest() {}
+
+std::string ListTagValuesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void ListTagValuesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string ListTagValuesRequest::getMatchType() const {
+  return matchType_;
+}
+
+void ListTagValuesRequest::setMatchType(const std::string &matchType) {
+  matchType_ = matchType;
+  setParameter(std::string("MatchType"), matchType);
+}
+
+std::string ListTagValuesRequest::getTagValue() const {
+  return tagValue_;
+}
+
+void ListTagValuesRequest::setTagValue(const std::string &tagValue) {
+  tagValue_ = tagValue;
+  setParameter(std::string("TagValue"), tagValue);
+}
+
+int ListTagValuesRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void ListTagValuesRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string ListTagValuesRequest::getTagKey() const {
+  return tagKey_;
+}
+
+void ListTagValuesRequest::setTagKey(const std::string &tagKey) {
+  tagKey_ = tagKey;
+  setParameter(std::string("TagKey"), tagKey);
+}
+

resourcecenter/src/model/ListTagValuesResult.cc

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/ListTagValuesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceCenter;
+using namespace AlibabaCloud::ResourceCenter::Model;
+
+ListTagValuesResult::ListTagValuesResult() :
+	ServiceResult()
+{}
+
+ListTagValuesResult::ListTagValuesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListTagValuesResult::~ListTagValuesResult()
+{}
+
+void ListTagValuesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagValues = value["TagValues"]["TagValue"];
+	for (const auto &item : allTagValues)
+		tagValues_.push_back(item.asString());
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["DynamicCode"].isNull())
+		dynamicCode_ = value["DynamicCode"].asString();
+	if(!value["DynamicMessage"].isNull())
+		dynamicMessage_ = value["DynamicMessage"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+
+}
+
+std::string ListTagValuesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string ListTagValuesResult::getDynamicCode()const
+{
+	return dynamicCode_;
+}
+
+std::string ListTagValuesResult::getDynamicMessage()const
+{
+	return dynamicMessage_;
+}
+
+std::string ListTagValuesResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListTagValuesResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+std::vector<std::string> ListTagValuesResult::getTagValues()const
+{
+	return tagValues_;
+}
+
+bool ListTagValuesResult::getSuccess()const
+{
+	return success_;
+}
+

resourcecenter/src/model/SearchMultiAccountResourcesRequest.cc

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/SearchMultiAccountResourcesRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::SearchMultiAccountResourcesRequest;
+
+SearchMultiAccountResourcesRequest::SearchMultiAccountResourcesRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "SearchMultiAccountResources") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SearchMultiAccountResourcesRequest::~SearchMultiAccountResourcesRequest() {}
+
+std::string SearchMultiAccountResourcesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void SearchMultiAccountResourcesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string SearchMultiAccountResourcesRequest::getScope() const {
+  return scope_;
+}
+
+void SearchMultiAccountResourcesRequest::setScope(const std::string &scope) {
+  scope_ = scope;
+  setParameter(std::string("Scope"), scope);
+}
+
+SearchMultiAccountResourcesRequest::SortCriterion SearchMultiAccountResourcesRequest::getSortCriterion() const {
+  return sortCriterion_;
+}
+
+void SearchMultiAccountResourcesRequest::setSortCriterion(const SearchMultiAccountResourcesRequest::SortCriterion &sortCriterion) {
+  sortCriterion_ = sortCriterion;
+  setParameter(std::string("SortCriterion") + ".Key", sortCriterion.key);
+  setParameter(std::string("SortCriterion") + ".Order", sortCriterion.order);
+}
+
+std::vector<SearchMultiAccountResourcesRequest::Filter> SearchMultiAccountResourcesRequest::getFilter() const {
+  return filter_;
+}
+
+void SearchMultiAccountResourcesRequest::setFilter(const std::vector<SearchMultiAccountResourcesRequest::Filter> &filter) {
+  filter_ = filter;
+  for(int dep1 = 0; dep1 != filter.size(); dep1++) {
+  auto filterObj = filter.at(dep1);
+  std::string filterObjStr = std::string("Filter") + "." + std::to_string(dep1 + 1);
+    setParameter(filterObjStr + ".MatchType", filterObj.matchType);
+    setParameter(filterObjStr + ".Key", filterObj.key);
+  }
+}
+
+int SearchMultiAccountResourcesRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void SearchMultiAccountResourcesRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+

resourcecenter/src/model/SearchMultiAccountResourcesResult.cc

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/SearchMultiAccountResourcesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceCenter;
+using namespace AlibabaCloud::ResourceCenter::Model;
+
+SearchMultiAccountResourcesResult::SearchMultiAccountResourcesResult() :
+	ServiceResult()
+{}
+
+SearchMultiAccountResourcesResult::SearchMultiAccountResourcesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SearchMultiAccountResourcesResult::~SearchMultiAccountResourcesResult()
+{}
+
+void SearchMultiAccountResourcesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allFiltersNode = value["Filters"]["Filter"];
+	for (auto valueFiltersFilter : allFiltersNode)
+	{
+		Filter filtersObject;
+		if(!valueFiltersFilter["Key"].isNull())
+			filtersObject.key = valueFiltersFilter["Key"].asString();
+		if(!valueFiltersFilter["MatchType"].isNull())
+			filtersObject.matchType = valueFiltersFilter["MatchType"].asString();
+		auto allValues = value["Values"]["Value"];
+		for (auto value : allValues)
+			filtersObject.values.push_back(value.asString());
+		filters_.push_back(filtersObject);
+	}
+	auto allResourcesNode = value["Resources"]["Resource"];
+	for (auto valueResourcesResource : allResourcesNode)
+	{
+		Resource resourcesObject;
+		if(!valueResourcesResource["ResourceType"].isNull())
+			resourcesObject.resourceType = valueResourcesResource["ResourceType"].asString();
+		if(!valueResourcesResource["CreateTime"].isNull())
+			resourcesObject.createTime = valueResourcesResource["CreateTime"].asString();
+		if(!valueResourcesResource["ResourceGroupId"].isNull())
+			resourcesObject.resourceGroupId = valueResourcesResource["ResourceGroupId"].asString();
+		if(!valueResourcesResource["ZoneId"].isNull())
+			resourcesObject.zoneId = valueResourcesResource["ZoneId"].asString();
+		if(!valueResourcesResource["AccountId"].isNull())
+			resourcesObject.accountId = valueResourcesResource["AccountId"].asString();
+		if(!valueResourcesResource["ResourceId"].isNull())
+			resourcesObject.resourceId = valueResourcesResource["ResourceId"].asString();
+		if(!valueResourcesResource["ResourceName"].isNull())
+			resourcesObject.resourceName = valueResourcesResource["ResourceName"].asString();
+		if(!valueResourcesResource["RegionId"].isNull())
+			resourcesObject.regionId = valueResourcesResource["RegionId"].asString();
+		auto allTagsNode = valueResourcesResource["Tags"]["Tag"];
+		for (auto valueResourcesResourceTagsTag : allTagsNode)
+		{
+			Resource::Tag tagsObject;
+			if(!valueResourcesResourceTagsTag["Key"].isNull())
+				tagsObject.key = valueResourcesResourceTagsTag["Key"].asString();
+			if(!valueResourcesResourceTagsTag["Value"].isNull())
+				tagsObject.value = valueResourcesResourceTagsTag["Value"].asString();
+			resourcesObject.tags.push_back(tagsObject);
+		}
+		auto allIpAddresses = value["IpAddresses"]["IpAddress"];
+		for (auto value : allIpAddresses)
+			resourcesObject.ipAddresses.push_back(value.asString());
+		resources_.push_back(resourcesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["Scope"].isNull())
+		scope_ = value["Scope"].asString();
+	if(!value["MaxResults"].isNull())
+		maxResults_ = std::stoi(value["MaxResults"].asString());
+
+}
+
+std::vector<SearchMultiAccountResourcesResult::Filter> SearchMultiAccountResourcesResult::getFilters()const
+{
+	return filters_;
+}
+
+std::string SearchMultiAccountResourcesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string SearchMultiAccountResourcesResult::getScope()const
+{
+	return scope_;
+}
+
+int SearchMultiAccountResourcesResult::getMaxResults()const
+{
+	return maxResults_;
+}
+
+std::vector<SearchMultiAccountResourcesResult::Resource> SearchMultiAccountResourcesResult::getResources()const
+{
+	return resources_;
+}
+

resourcecenter/src/model/SearchResourcesRequest.cc

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/resourcecenter/model/SearchResourcesRequest.h>
+
+using AlibabaCloud::ResourceCenter::Model::SearchResourcesRequest;
+
+SearchResourcesRequest::SearchResourcesRequest()
+    : RpcServiceRequest("resourcecenter", "2022-12-01", "SearchResources") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+SearchResourcesRequest::~SearchResourcesRequest() {}
+
+std::string SearchResourcesRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void SearchResourcesRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string SearchResourcesRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void SearchResourcesRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+SearchResourcesRequest::SortCriterion SearchResourcesRequest::getSortCriterion() const {
+  return sortCriterion_;
+}
+
+void SearchResourcesRequest::setSortCriterion(const SearchResourcesRequest::SortCriterion &sortCriterion) {
+  sortCriterion_ = sortCriterion;
+  setParameter(std::string("SortCriterion") + ".Key", sortCriterion.key);
+  setParameter(std::string("SortCriterion") + ".Order", sortCriterion.order);
+}
+
+std::vector<SearchResourcesRequest::Filter> SearchResourcesRequest::getFilter() const {
+  return filter_;
+}
+
+void SearchResourcesRequest::setFilter(const std::vector<SearchResourcesRequest::Filter> &filter) {
+  filter_ = filter;
+  for(int dep1 = 0; dep1 != filter.size(); dep1++) {
+  auto filterObj = filter.at(dep1);
+  std::string filterObjStr = std::string("Filter") + "." + std::to_string(dep1 + 1);
+    setParameter(filterObjStr + ".MatchType", filterObj.matchType);
+    setParameter(filterObjStr + ".Key", filterObj.key);
+  }
+}
+
+int SearchResourcesRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void SearchResourcesRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+

resourcecenter/src/model/SearchResourcesResult.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/resourcecenter/model/SearchResourcesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::ResourceCenter;
+using namespace AlibabaCloud::ResourceCenter::Model;
+
+SearchResourcesResult::SearchResourcesResult() :
+	ServiceResult()
+{}
+
+SearchResourcesResult::SearchResourcesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SearchResourcesResult::~SearchResourcesResult()
+{}
+
+void SearchResourcesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allFiltersNode = value["Filters"]["Filter"];
+	for (auto valueFiltersFilter : allFiltersNode)
+	{
+		Filter filtersObject;
+		if(!valueFiltersFilter["Key"].isNull())
+			filtersObject.key = valueFiltersFilter["Key"].asString();
+		if(!valueFiltersFilter["MatchType"].isNull())
+			filtersObject.matchType = valueFiltersFilter["MatchType"].asString();
+		auto allValues = value["Values"]["Value"];
+		for (auto value : allValues)
+			filtersObject.values.push_back(value.asString());
+		filters_.push_back(filtersObject);
+	}
+	auto allResourcesNode = value["Resources"]["Resource"];
+	for (auto valueResourcesResource : allResourcesNode)
+	{
+		Resource resourcesObject;
+		if(!valueResourcesResource["ResourceType"].isNull())
+			resourcesObject.resourceType = valueResourcesResource["ResourceType"].asString();
+		if(!valueResourcesResource["CreateTime"].isNull())
+			resourcesObject.createTime = valueResourcesResource["CreateTime"].asString();
+		if(!valueResourcesResource["ResourceGroupId"].isNull())
+			resourcesObject.resourceGroupId = valueResourcesResource["ResourceGroupId"].asString();
+		if(!valueResourcesResource["ZoneId"].isNull())
+			resourcesObject.zoneId = valueResourcesResource["ZoneId"].asString();
+		if(!valueResourcesResource["AccountId"].isNull())
+			resourcesObject.accountId = valueResourcesResource["AccountId"].asString();
+		if(!valueResourcesResource["ResourceId"].isNull())
+			resourcesObject.resourceId = valueResourcesResource["ResourceId"].asString();
+		if(!valueResourcesResource["ResourceName"].isNull())
+			resourcesObject.resourceName = valueResourcesResource["ResourceName"].asString();
+		if(!valueResourcesResource["RegionId"].isNull())
+			resourcesObject.regionId = valueResourcesResource["RegionId"].asString();
+		auto allTagsNode = valueResourcesResource["Tags"]["Tag"];
+		for (auto valueResourcesResourceTagsTag : allTagsNode)
+		{
+			Resource::Tag tagsObject;
+			if(!valueResourcesResourceTagsTag["Key"].isNull())
+				tagsObject.key = valueResourcesResourceTagsTag["Key"].asString();
+			if(!valueResourcesResourceTagsTag["Value"].isNull())
+				tagsObject.value = valueResourcesResourceTagsTag["Value"].asString();
+			resourcesObject.tags.push_back(tagsObject);
+		}
+		auto allIpAddresses = value["IpAddresses"]["IpAddress"];
+		for (auto value : allIpAddresses)
+			resourcesObject.ipAddresses.push_back(value.asString());
+		resources_.push_back(resourcesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["MaxResults"].isNull())
+		maxResults_ = std::stoi(value["MaxResults"].asString());
+
+}
+
+std::vector<SearchResourcesResult::Filter> SearchResourcesResult::getFilters()const
+{
+	return filters_;
+}
+
+std::string SearchResourcesResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+int SearchResourcesResult::getMaxResults()const
+{
+	return maxResults_;
+}
+
+std::vector<SearchResourcesResult::Resource> SearchResourcesResult::getResources()const
+{
+	return resources_;
+}
+