Supported webpage scan.

CHANGELOG

@@ -1,3 +1,127 @@
+2020-11-18 Version: patch
+- Supported webpage scan.
+
+2020-11-17 Version: patch
+- Support event type in timeline of resource properties.
+- Support resourceOwnerId in evaluation result.
+- Support resource directory in config rule scene.
+- Fix terraform related bugs.
+
+2020-11-17 Version: patch
+- Support ModifyDBClusterPrimaryZone.
+- Support DescribeGlobalDatabaseNetworks.
+
+2020-11-17 Version: patch
+- Supported International-26888 Sites Region Endpoints.
+
+2020-11-17 Version: patch
+- Supported International-26888 Sites Region Endpoints.
+
+2020-11-16 Version: patch
+- Nat public IP supports the ISP attribute.
+
+2020-11-16 Version: patch
+- Add a new interface for asynchronous image translation.
+
+2020-11-16 Version: patch
+- Update videoenhan.
+
+2020-11-16 Version: patch
+- Update videoseg.
+
+2020-11-16 Version: patch
+- Update videorecog.
+
+2020-11-16 Version: patch
+- Update objectdet.
+
+2020-11-16 Version: patch
+- Update imgsearch.
+
+2020-11-16 Version: patch
+- Update imagerecog.
+
+2020-11-16 Version: patch
+- Update goodstech.
+
+2020-11-13 Version: patch
+- Update Imageaudit.
+
+2020-11-13 Version: patch
+- Add DeccribeEngineVersion DescribeTasks DescribeInstanceConfig and more APIs.
+
+2020-11-13 Version: patch
+- Fix GetBranchInfo and DeleteBranch API 404 error.
+- Add ListRepositoryBranches and GetGroupDetail API.
+
+2020-11-13 Version: patch
+- Release ErasePerson.
+
+2020-11-13 Version: patch
+- Release DetectCardScreenshot RecognizePoiName.
+
+2020-11-13 Version: patch
+- Release GenerateHumanAnimeStyle CountCrowd.
+
+2020-11-13 Version: patch
+- Release SegmentHDSky SegmentHDCommonImage.
+
+2020-11-12 Version: patch
+- Support drm.
+
+2020-11-12 Version: patch
+- Generated 2019-06-01 for `smc`.
+
+2020-11-12 Version: patch
+- Update new version.
+
+2020-11-12 Version: patch
+- Support DescribeDBClusterTDE.
+- Support ModifyDBClusterTDE.
+
+2020-11-12 Version: patch
+- Supported Open Api.
+
+2020-11-12 Version: patch
+- Support OpenAPI.
+
+2020-11-12 Version: patch
+- Update DescribeTrails Response.
+
+2020-11-05 Version: patch
+- Support modifyInstnaceType.
+
+2020-11-04 Version: patch
+- Generated 2019-01-01 for `Cassandra`.
+
+2020-11-04 Version: patch
+- Support modifyInstnaceType.
+
+2020-11-04 Version: patch
+- Generated 2019-01-01 for `Cassandra`.
+
+2020-11-04 Version: patch
+- Support modifyInstnaceType.
+
+2020-11-03 Version: patch
+- Minor update for r-kvstore.
+
+2020-11-03 Version: patch
+- Update data API.
+
+2020-11-02 Version: patch
+- Support create serverless by day price type.
+
+2020-11-01 Version: patch
+- Supported All Console APIs.
+
+2020-10-28 Version: patch
+- Support GetParameters, GetParametersByPath, GetSecretParameters, GetSecretParametersByPath.
+
+2020-10-28 Version: patch
+- Supported all language sdk.
+- Fixed some bugs for polardbx.
+
 2020-10-28 Version: patch
 - Supported golang sdk.
 - Fixed some bugs for drds.

actiontrail/CMakeLists.txt

@@ -0,0 +1,118 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(actiontrail_public_header 
+	include/alibabacloud/actiontrail/ActiontrailClient.h
+	include/alibabacloud/actiontrail/ActiontrailExport.h )
+
+set(actiontrail_public_header_model 
+	include/alibabacloud/actiontrail/model/CreateTrailRequest.h
+	include/alibabacloud/actiontrail/model/CreateTrailResult.h
+	include/alibabacloud/actiontrail/model/DeleteTrailRequest.h
+	include/alibabacloud/actiontrail/model/DeleteTrailResult.h
+	include/alibabacloud/actiontrail/model/DescribeRegionsRequest.h
+	include/alibabacloud/actiontrail/model/DescribeRegionsResult.h
+	include/alibabacloud/actiontrail/model/DescribeTrailsRequest.h
+	include/alibabacloud/actiontrail/model/DescribeTrailsResult.h
+	include/alibabacloud/actiontrail/model/GetTrailStatusRequest.h
+	include/alibabacloud/actiontrail/model/GetTrailStatusResult.h
+	include/alibabacloud/actiontrail/model/LookupEventsRequest.h
+	include/alibabacloud/actiontrail/model/LookupEventsResult.h
+	include/alibabacloud/actiontrail/model/StartLoggingRequest.h
+	include/alibabacloud/actiontrail/model/StartLoggingResult.h
+	include/alibabacloud/actiontrail/model/StopLoggingRequest.h
+	include/alibabacloud/actiontrail/model/StopLoggingResult.h
+	include/alibabacloud/actiontrail/model/UpdateTrailRequest.h
+	include/alibabacloud/actiontrail/model/UpdateTrailResult.h )
+
+set(actiontrail_src 
+	src/ActiontrailClient.cc
+	src/model/CreateTrailRequest.cc
+	src/model/CreateTrailResult.cc
+	src/model/DeleteTrailRequest.cc
+	src/model/DeleteTrailResult.cc
+	src/model/DescribeRegionsRequest.cc
+	src/model/DescribeRegionsResult.cc
+	src/model/DescribeTrailsRequest.cc
+	src/model/DescribeTrailsResult.cc
+	src/model/GetTrailStatusRequest.cc
+	src/model/GetTrailStatusResult.cc
+	src/model/LookupEventsRequest.cc
+	src/model/LookupEventsResult.cc
+	src/model/StartLoggingRequest.cc
+	src/model/StartLoggingResult.cc
+	src/model/StopLoggingRequest.cc
+	src/model/StopLoggingResult.cc
+	src/model/UpdateTrailRequest.cc
+	src/model/UpdateTrailResult.cc )
+
+add_library(actiontrail ${LIB_TYPE}
+	${actiontrail_public_header}
+	${actiontrail_public_header_model}
+	${actiontrail_src})
+
+set_target_properties(actiontrail
+	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}actiontrail
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(actiontrail
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_ACTIONTRAIL_LIBRARY)
+endif()
+
+target_include_directories(actiontrail
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(actiontrail
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(actiontrail
+		jsoncpp)
+	target_include_directories(actiontrail
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(actiontrail
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(actiontrail
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(actiontrail
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(actiontrail
+		jsoncpp)
+endif()
+
+install(FILES ${actiontrail_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/actiontrail)
+install(FILES ${actiontrail_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/actiontrail/model)
+install(TARGETS actiontrail
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

actiontrail/include/alibabacloud/actiontrail/ActiontrailClient.h

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_ACTIONTRAIL_ACTIONTRAILCLIENT_H_
+#define ALIBABACLOUD_ACTIONTRAIL_ACTIONTRAILCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ActiontrailExport.h"
+#include "model/CreateTrailRequest.h"
+#include "model/CreateTrailResult.h"
+#include "model/DeleteTrailRequest.h"
+#include "model/DeleteTrailResult.h"
+#include "model/DescribeRegionsRequest.h"
+#include "model/DescribeRegionsResult.h"
+#include "model/DescribeTrailsRequest.h"
+#include "model/DescribeTrailsResult.h"
+#include "model/GetTrailStatusRequest.h"
+#include "model/GetTrailStatusResult.h"
+#include "model/LookupEventsRequest.h"
+#include "model/LookupEventsResult.h"
+#include "model/StartLoggingRequest.h"
+#include "model/StartLoggingResult.h"
+#include "model/StopLoggingRequest.h"
+#include "model/StopLoggingResult.h"
+#include "model/UpdateTrailRequest.h"
+#include "model/UpdateTrailResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		class ALIBABACLOUD_ACTIONTRAIL_EXPORT ActiontrailClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::CreateTrailResult> CreateTrailOutcome;
+			typedef std::future<CreateTrailOutcome> CreateTrailOutcomeCallable;
+			typedef std::function<void(const ActiontrailClient*, const Model::CreateTrailRequest&, const CreateTrailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTrailAsyncHandler;
+			typedef Outcome<Error, Model::DeleteTrailResult> DeleteTrailOutcome;
+			typedef std::future<DeleteTrailOutcome> DeleteTrailOutcomeCallable;
+			typedef std::function<void(const ActiontrailClient*, const Model::DeleteTrailRequest&, const DeleteTrailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTrailAsyncHandler;
+			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
+			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
+			typedef std::function<void(const ActiontrailClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeTrailsResult> DescribeTrailsOutcome;
+			typedef std::future<DescribeTrailsOutcome> DescribeTrailsOutcomeCallable;
+			typedef std::function<void(const ActiontrailClient*, const Model::DescribeTrailsRequest&, const DescribeTrailsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTrailsAsyncHandler;
+			typedef Outcome<Error, Model::GetTrailStatusResult> GetTrailStatusOutcome;
+			typedef std::future<GetTrailStatusOutcome> GetTrailStatusOutcomeCallable;
+			typedef std::function<void(const ActiontrailClient*, const Model::GetTrailStatusRequest&, const GetTrailStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTrailStatusAsyncHandler;
+			typedef Outcome<Error, Model::LookupEventsResult> LookupEventsOutcome;
+			typedef std::future<LookupEventsOutcome> LookupEventsOutcomeCallable;
+			typedef std::function<void(const ActiontrailClient*, const Model::LookupEventsRequest&, const LookupEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LookupEventsAsyncHandler;
+			typedef Outcome<Error, Model::StartLoggingResult> StartLoggingOutcome;
+			typedef std::future<StartLoggingOutcome> StartLoggingOutcomeCallable;
+			typedef std::function<void(const ActiontrailClient*, const Model::StartLoggingRequest&, const StartLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartLoggingAsyncHandler;
+			typedef Outcome<Error, Model::StopLoggingResult> StopLoggingOutcome;
+			typedef std::future<StopLoggingOutcome> StopLoggingOutcomeCallable;
+			typedef std::function<void(const ActiontrailClient*, const Model::StopLoggingRequest&, const StopLoggingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopLoggingAsyncHandler;
+			typedef Outcome<Error, Model::UpdateTrailResult> UpdateTrailOutcome;
+			typedef std::future<UpdateTrailOutcome> UpdateTrailOutcomeCallable;
+			typedef std::function<void(const ActiontrailClient*, const Model::UpdateTrailRequest&, const UpdateTrailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateTrailAsyncHandler;
+
+			ActiontrailClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ActiontrailClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ActiontrailClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ActiontrailClient();
+			CreateTrailOutcome createTrail(const Model::CreateTrailRequest &request)const;
+			void createTrailAsync(const Model::CreateTrailRequest& request, const CreateTrailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateTrailOutcomeCallable createTrailCallable(const Model::CreateTrailRequest& request) const;
+			DeleteTrailOutcome deleteTrail(const Model::DeleteTrailRequest &request)const;
+			void deleteTrailAsync(const Model::DeleteTrailRequest& request, const DeleteTrailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteTrailOutcomeCallable deleteTrailCallable(const Model::DeleteTrailRequest& request) const;
+			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
+			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
+			DescribeTrailsOutcome describeTrails(const Model::DescribeTrailsRequest &request)const;
+			void describeTrailsAsync(const Model::DescribeTrailsRequest& request, const DescribeTrailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeTrailsOutcomeCallable describeTrailsCallable(const Model::DescribeTrailsRequest& request) const;
+			GetTrailStatusOutcome getTrailStatus(const Model::GetTrailStatusRequest &request)const;
+			void getTrailStatusAsync(const Model::GetTrailStatusRequest& request, const GetTrailStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTrailStatusOutcomeCallable getTrailStatusCallable(const Model::GetTrailStatusRequest& request) const;
+			LookupEventsOutcome lookupEvents(const Model::LookupEventsRequest &request)const;
+			void lookupEventsAsync(const Model::LookupEventsRequest& request, const LookupEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			LookupEventsOutcomeCallable lookupEventsCallable(const Model::LookupEventsRequest& request) const;
+			StartLoggingOutcome startLogging(const Model::StartLoggingRequest &request)const;
+			void startLoggingAsync(const Model::StartLoggingRequest& request, const StartLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartLoggingOutcomeCallable startLoggingCallable(const Model::StartLoggingRequest& request) const;
+			StopLoggingOutcome stopLogging(const Model::StopLoggingRequest &request)const;
+			void stopLoggingAsync(const Model::StopLoggingRequest& request, const StopLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopLoggingOutcomeCallable stopLoggingCallable(const Model::StopLoggingRequest& request) const;
+			UpdateTrailOutcome updateTrail(const Model::UpdateTrailRequest &request)const;
+			void updateTrailAsync(const Model::UpdateTrailRequest& request, const UpdateTrailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateTrailOutcomeCallable updateTrailCallable(const Model::UpdateTrailRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_ACTIONTRAIL_ACTIONTRAILCLIENT_H_

actiontrail/include/alibabacloud/actiontrail/ActiontrailExport.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_ACTIONTRAIL_ACTIONTRAILEXPORT_H_
+#define ALIBABACLOUD_ACTIONTRAIL_ACTIONTRAILEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_ACTIONTRAIL_LIBRARY)
+#		define ALIBABACLOUD_ACTIONTRAIL_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_ACTIONTRAIL_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_ACTIONTRAIL_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_ACTIONTRAIL_ACTIONTRAILEXPORT_H_

actiontrail/include/alibabacloud/actiontrail/model/CreateTrailRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_ACTIONTRAIL_MODEL_CREATETRAILREQUEST_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_CREATETRAILREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT CreateTrailRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateTrailRequest();
+				~CreateTrailRequest();
+
+				std::string getSlsProjectArn()const;
+				void setSlsProjectArn(const std::string& slsProjectArn);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSlsWriteRoleArn()const;
+				void setSlsWriteRoleArn(const std::string& slsWriteRoleArn);
+				bool getIsOrganizationTrail()const;
+				void setIsOrganizationTrail(bool isOrganizationTrail);
+				std::string getOssKeyPrefix()const;
+				void setOssKeyPrefix(const std::string& ossKeyPrefix);
+				std::string getMnsTopicArn()const;
+				void setMnsTopicArn(const std::string& mnsTopicArn);
+				std::string getRoleName()const;
+				void setRoleName(const std::string& roleName);
+				std::string getEventRW()const;
+				void setEventRW(const std::string& eventRW);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getOssBucketName()const;
+				void setOssBucketName(const std::string& ossBucketName);
+				std::string getTrailRegion()const;
+				void setTrailRegion(const std::string& trailRegion);
+
+            private:
+				std::string slsProjectArn_;
+				std::string accessKeyId_;
+				std::string slsWriteRoleArn_;
+				bool isOrganizationTrail_;
+				std::string ossKeyPrefix_;
+				std::string mnsTopicArn_;
+				std::string roleName_;
+				std::string eventRW_;
+				std::string name_;
+				std::string ossBucketName_;
+				std::string trailRegion_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_CREATETRAILREQUEST_H_

actiontrail/include/alibabacloud/actiontrail/model/CreateTrailResult.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACTIONTRAIL_MODEL_CREATETRAILRESULT_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_CREATETRAILRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT CreateTrailResult : public ServiceResult
+			{
+			public:
+
+
+				CreateTrailResult();
+				explicit CreateTrailResult(const std::string &payload);
+				~CreateTrailResult();
+				std::string getSlsProjectArn()const;
+				std::string getMnsTopicArn()const;
+				std::string getRoleName()const;
+				std::string getEventRW()const;
+				std::string getHomeRegion()const;
+				std::string getOssKeyPrefix()const;
+				std::string getOssBucketName()const;
+				std::string getSlsWriteRoleArn()const;
+				std::string getTrailRegion()const;
+				std::string getName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string slsProjectArn_;
+				std::string mnsTopicArn_;
+				std::string roleName_;
+				std::string eventRW_;
+				std::string homeRegion_;
+				std::string ossKeyPrefix_;
+				std::string ossBucketName_;
+				std::string slsWriteRoleArn_;
+				std::string trailRegion_;
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_CREATETRAILRESULT_H_

actiontrail/include/alibabacloud/actiontrail/model/DeleteTrailRequest.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_ACTIONTRAIL_MODEL_DELETETRAILREQUEST_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_DELETETRAILREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT DeleteTrailRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteTrailRequest();
+				~DeleteTrailRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getName()const;
+				void setName(const std::string& name);
+
+            private:
+				std::string accessKeyId_;
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_DELETETRAILREQUEST_H_

actiontrail/include/alibabacloud/actiontrail/model/DeleteTrailResult.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_ACTIONTRAIL_MODEL_DELETETRAILRESULT_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_DELETETRAILRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT DeleteTrailResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteTrailResult();
+				explicit DeleteTrailResult(const std::string &payload);
+				~DeleteTrailResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_DELETETRAILRESULT_H_

actiontrail/include/alibabacloud/actiontrail/model/DescribeRegionsRequest.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_ACTIONTRAIL_MODEL_DESCRIBEREGIONSREQUEST_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_DESCRIBEREGIONSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT DescribeRegionsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeRegionsRequest();
+				~DescribeRegionsRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_DESCRIBEREGIONSREQUEST_H_

actiontrail/include/alibabacloud/actiontrail/model/DescribeRegionsResult.h

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

actiontrail/include/alibabacloud/actiontrail/model/DescribeTrailsRequest.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_ACTIONTRAIL_MODEL_DESCRIBETRAILSREQUEST_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_DESCRIBETRAILSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT DescribeTrailsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeTrailsRequest();
+				~DescribeTrailsRequest();
+
+				bool getIncludeShadowTrails()const;
+				void setIncludeShadowTrails(bool includeShadowTrails);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getNameList()const;
+				void setNameList(const std::string& nameList);
+
+            private:
+				bool includeShadowTrails_;
+				std::string accessKeyId_;
+				std::string nameList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_DESCRIBETRAILSREQUEST_H_

actiontrail/include/alibabacloud/actiontrail/model/DescribeTrailsResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACTIONTRAIL_MODEL_DESCRIBETRAILSRESULT_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_DESCRIBETRAILSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT DescribeTrailsResult : public ServiceResult
+			{
+			public:
+				struct TrailListItem
+				{
+					std::string status;
+					std::string mnsTopicArn;
+					std::string homeRegion;
+					std::string createTime;
+					std::string startLoggingTime;
+					std::string stopLoggingTime;
+					std::string slsWriteRoleArn;
+					std::string trailRegion;
+					std::string name;
+					bool isOrganizationTrail;
+					std::string slsProjectArn;
+					std::string roleName;
+					std::string eventRW;
+					std::string ossKeyPrefix;
+					std::string updateTime;
+					std::string ossBucketName;
+				};
+
+
+				DescribeTrailsResult();
+				explicit DescribeTrailsResult(const std::string &payload);
+				~DescribeTrailsResult();
+				std::vector<TrailListItem> getTrailList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<TrailListItem> trailList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_DESCRIBETRAILSRESULT_H_

actiontrail/include/alibabacloud/actiontrail/model/GetTrailStatusRequest.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_ACTIONTRAIL_MODEL_GETTRAILSTATUSREQUEST_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_GETTRAILSTATUSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT GetTrailStatusRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetTrailStatusRequest();
+				~GetTrailStatusRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getName()const;
+				void setName(const std::string& name);
+				bool getIsOrganizationTrail()const;
+				void setIsOrganizationTrail(bool isOrganizationTrail);
+
+            private:
+				std::string accessKeyId_;
+				std::string name_;
+				bool isOrganizationTrail_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_GETTRAILSTATUSREQUEST_H_

actiontrail/include/alibabacloud/actiontrail/model/GetTrailStatusResult.h

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

actiontrail/include/alibabacloud/actiontrail/model/LookupEventsRequest.h

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACTIONTRAIL_MODEL_LOOKUPEVENTSREQUEST_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_LOOKUPEVENTSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT LookupEventsRequest : public RpcServiceRequest
+			{
+
+			public:
+				LookupEventsRequest();
+				~LookupEventsRequest();
+
+				std::string getRequest()const;
+				void setRequest(const std::string& request);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getEventName()const;
+				void setEventName(const std::string& eventName);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getNextToken()const;
+				void setNextToken(const std::string& nextToken);
+				std::string getServiceName()const;
+				void setServiceName(const std::string& serviceName);
+				std::string getEvent()const;
+				void setEvent(const std::string& event);
+				std::string getEventAccessKeyId()const;
+				void setEventAccessKeyId(const std::string& eventAccessKeyId);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getEventRW()const;
+				void setEventRW(const std::string& eventRW);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+				std::string getMaxResults()const;
+				void setMaxResults(const std::string& maxResults);
+				std::string getEventType()const;
+				void setEventType(const std::string& eventType);
+				std::string getResourceName()const;
+				void setResourceName(const std::string& resourceName);
+				std::string getUser()const;
+				void setUser(const std::string& user);
+
+            private:
+				std::string request_;
+				std::string startTime_;
+				std::string eventName_;
+				std::string accessKeyId_;
+				std::string nextToken_;
+				std::string serviceName_;
+				std::string event_;
+				std::string eventAccessKeyId_;
+				std::string endTime_;
+				std::string eventRW_;
+				std::string resourceType_;
+				std::string maxResults_;
+				std::string eventType_;
+				std::string resourceName_;
+				std::string user_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_LOOKUPEVENTSREQUEST_H_

actiontrail/include/alibabacloud/actiontrail/model/LookupEventsResult.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_ACTIONTRAIL_MODEL_LOOKUPEVENTSRESULT_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_LOOKUPEVENTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT LookupEventsResult : public ServiceResult
+			{
+			public:
+
+
+				LookupEventsResult();
+				explicit LookupEventsResult(const std::string &payload);
+				~LookupEventsResult();
+				std::string getNextToken()const;
+				std::string getEndTime()const;
+				std::vector<std::string> getEvents()const;
+				std::string getStartTime()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string endTime_;
+				std::vector<std::string> events_;
+				std::string startTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_LOOKUPEVENTSRESULT_H_

actiontrail/include/alibabacloud/actiontrail/model/StartLoggingRequest.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_ACTIONTRAIL_MODEL_STARTLOGGINGREQUEST_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_STARTLOGGINGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT StartLoggingRequest : public RpcServiceRequest
+			{
+
+			public:
+				StartLoggingRequest();
+				~StartLoggingRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getName()const;
+				void setName(const std::string& name);
+
+            private:
+				std::string accessKeyId_;
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_STARTLOGGINGREQUEST_H_

actiontrail/include/alibabacloud/actiontrail/model/StartLoggingResult.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_ACTIONTRAIL_MODEL_STARTLOGGINGRESULT_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_STARTLOGGINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT StartLoggingResult : public ServiceResult
+			{
+			public:
+
+
+				StartLoggingResult();
+				explicit StartLoggingResult(const std::string &payload);
+				~StartLoggingResult();
+				std::string getParam()const;
+				std::string getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string param_;
+				std::string result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_STARTLOGGINGRESULT_H_

actiontrail/include/alibabacloud/actiontrail/model/StopLoggingRequest.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_ACTIONTRAIL_MODEL_STOPLOGGINGREQUEST_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_STOPLOGGINGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT StopLoggingRequest : public RpcServiceRequest
+			{
+
+			public:
+				StopLoggingRequest();
+				~StopLoggingRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getName()const;
+				void setName(const std::string& name);
+
+            private:
+				std::string accessKeyId_;
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_STOPLOGGINGREQUEST_H_

actiontrail/include/alibabacloud/actiontrail/model/StopLoggingResult.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_ACTIONTRAIL_MODEL_STOPLOGGINGRESULT_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_STOPLOGGINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT StopLoggingResult : public ServiceResult
+			{
+			public:
+
+
+				StopLoggingResult();
+				explicit StopLoggingResult(const std::string &payload);
+				~StopLoggingResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_STOPLOGGINGRESULT_H_

actiontrail/include/alibabacloud/actiontrail/model/UpdateTrailRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACTIONTRAIL_MODEL_UPDATETRAILREQUEST_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_UPDATETRAILREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT UpdateTrailRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpdateTrailRequest();
+				~UpdateTrailRequest();
+
+				std::string getSlsProjectArn()const;
+				void setSlsProjectArn(const std::string& slsProjectArn);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSlsWriteRoleArn()const;
+				void setSlsWriteRoleArn(const std::string& slsWriteRoleArn);
+				std::string getOssKeyPrefix()const;
+				void setOssKeyPrefix(const std::string& ossKeyPrefix);
+				std::string getMnsTopicArn()const;
+				void setMnsTopicArn(const std::string& mnsTopicArn);
+				std::string getRoleName()const;
+				void setRoleName(const std::string& roleName);
+				std::string getEventRW()const;
+				void setEventRW(const std::string& eventRW);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getOssBucketName()const;
+				void setOssBucketName(const std::string& ossBucketName);
+				std::string getTrailRegion()const;
+				void setTrailRegion(const std::string& trailRegion);
+
+            private:
+				std::string slsProjectArn_;
+				std::string accessKeyId_;
+				std::string slsWriteRoleArn_;
+				std::string ossKeyPrefix_;
+				std::string mnsTopicArn_;
+				std::string roleName_;
+				std::string eventRW_;
+				std::string name_;
+				std::string ossBucketName_;
+				std::string trailRegion_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_UPDATETRAILREQUEST_H_

actiontrail/include/alibabacloud/actiontrail/model/UpdateTrailResult.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ACTIONTRAIL_MODEL_UPDATETRAILRESULT_H_
+#define ALIBABACLOUD_ACTIONTRAIL_MODEL_UPDATETRAILRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/actiontrail/ActiontrailExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Actiontrail
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ACTIONTRAIL_EXPORT UpdateTrailResult : public ServiceResult
+			{
+			public:
+
+
+				UpdateTrailResult();
+				explicit UpdateTrailResult(const std::string &payload);
+				~UpdateTrailResult();
+				std::string getSlsProjectArn()const;
+				std::string getMnsTopicArn()const;
+				std::string getRoleName()const;
+				std::string getEventRW()const;
+				std::string getHomeRegion()const;
+				std::string getOssKeyPrefix()const;
+				std::string getOssBucketName()const;
+				std::string getSlsWriteRoleArn()const;
+				std::string getTrailRegion()const;
+				std::string getName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string slsProjectArn_;
+				std::string mnsTopicArn_;
+				std::string roleName_;
+				std::string eventRW_;
+				std::string homeRegion_;
+				std::string ossKeyPrefix_;
+				std::string ossBucketName_;
+				std::string slsWriteRoleArn_;
+				std::string trailRegion_;
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ACTIONTRAIL_MODEL_UPDATETRAILRESULT_H_

actiontrail/src/ActiontrailClient.cc

@@ -0,0 +1,377 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/actiontrail/ActiontrailClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Actiontrail;
+using namespace AlibabaCloud::Actiontrail::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "Actiontrail";
+}
+
+ActiontrailClient::ActiontrailClient(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, "actiontrail");
+}
+
+ActiontrailClient::ActiontrailClient(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, "actiontrail");
+}
+
+ActiontrailClient::ActiontrailClient(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, "actiontrail");
+}
+
+ActiontrailClient::~ActiontrailClient()
+{}
+
+ActiontrailClient::CreateTrailOutcome ActiontrailClient::createTrail(const CreateTrailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateTrailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateTrailOutcome(CreateTrailResult(outcome.result()));
+	else
+		return CreateTrailOutcome(outcome.error());
+}
+
+void ActiontrailClient::createTrailAsync(const CreateTrailRequest& request, const CreateTrailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createTrail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ActiontrailClient::CreateTrailOutcomeCallable ActiontrailClient::createTrailCallable(const CreateTrailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateTrailOutcome()>>(
+			[this, request]()
+			{
+			return this->createTrail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ActiontrailClient::DeleteTrailOutcome ActiontrailClient::deleteTrail(const DeleteTrailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteTrailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteTrailOutcome(DeleteTrailResult(outcome.result()));
+	else
+		return DeleteTrailOutcome(outcome.error());
+}
+
+void ActiontrailClient::deleteTrailAsync(const DeleteTrailRequest& request, const DeleteTrailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteTrail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ActiontrailClient::DeleteTrailOutcomeCallable ActiontrailClient::deleteTrailCallable(const DeleteTrailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteTrailOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteTrail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ActiontrailClient::DescribeRegionsOutcome ActiontrailClient::describeRegions(const DescribeRegionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeRegionsOutcome(DescribeRegionsResult(outcome.result()));
+	else
+		return DescribeRegionsOutcome(outcome.error());
+}
+
+void ActiontrailClient::describeRegionsAsync(const DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ActiontrailClient::DescribeRegionsOutcomeCallable ActiontrailClient::describeRegionsCallable(const DescribeRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ActiontrailClient::DescribeTrailsOutcome ActiontrailClient::describeTrails(const DescribeTrailsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeTrailsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeTrailsOutcome(DescribeTrailsResult(outcome.result()));
+	else
+		return DescribeTrailsOutcome(outcome.error());
+}
+
+void ActiontrailClient::describeTrailsAsync(const DescribeTrailsRequest& request, const DescribeTrailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeTrails(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ActiontrailClient::DescribeTrailsOutcomeCallable ActiontrailClient::describeTrailsCallable(const DescribeTrailsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeTrailsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeTrails(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ActiontrailClient::GetTrailStatusOutcome ActiontrailClient::getTrailStatus(const GetTrailStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetTrailStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetTrailStatusOutcome(GetTrailStatusResult(outcome.result()));
+	else
+		return GetTrailStatusOutcome(outcome.error());
+}
+
+void ActiontrailClient::getTrailStatusAsync(const GetTrailStatusRequest& request, const GetTrailStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getTrailStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ActiontrailClient::GetTrailStatusOutcomeCallable ActiontrailClient::getTrailStatusCallable(const GetTrailStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetTrailStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->getTrailStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ActiontrailClient::LookupEventsOutcome ActiontrailClient::lookupEvents(const LookupEventsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return LookupEventsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return LookupEventsOutcome(LookupEventsResult(outcome.result()));
+	else
+		return LookupEventsOutcome(outcome.error());
+}
+
+void ActiontrailClient::lookupEventsAsync(const LookupEventsRequest& request, const LookupEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, lookupEvents(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ActiontrailClient::LookupEventsOutcomeCallable ActiontrailClient::lookupEventsCallable(const LookupEventsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<LookupEventsOutcome()>>(
+			[this, request]()
+			{
+			return this->lookupEvents(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ActiontrailClient::StartLoggingOutcome ActiontrailClient::startLogging(const StartLoggingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartLoggingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartLoggingOutcome(StartLoggingResult(outcome.result()));
+	else
+		return StartLoggingOutcome(outcome.error());
+}
+
+void ActiontrailClient::startLoggingAsync(const StartLoggingRequest& request, const StartLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startLogging(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ActiontrailClient::StartLoggingOutcomeCallable ActiontrailClient::startLoggingCallable(const StartLoggingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartLoggingOutcome()>>(
+			[this, request]()
+			{
+			return this->startLogging(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ActiontrailClient::StopLoggingOutcome ActiontrailClient::stopLogging(const StopLoggingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopLoggingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopLoggingOutcome(StopLoggingResult(outcome.result()));
+	else
+		return StopLoggingOutcome(outcome.error());
+}
+
+void ActiontrailClient::stopLoggingAsync(const StopLoggingRequest& request, const StopLoggingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopLogging(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ActiontrailClient::StopLoggingOutcomeCallable ActiontrailClient::stopLoggingCallable(const StopLoggingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopLoggingOutcome()>>(
+			[this, request]()
+			{
+			return this->stopLogging(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ActiontrailClient::UpdateTrailOutcome ActiontrailClient::updateTrail(const UpdateTrailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateTrailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateTrailOutcome(UpdateTrailResult(outcome.result()));
+	else
+		return UpdateTrailOutcome(outcome.error());
+}
+
+void ActiontrailClient::updateTrailAsync(const UpdateTrailRequest& request, const UpdateTrailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateTrail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ActiontrailClient::UpdateTrailOutcomeCallable ActiontrailClient::updateTrailCallable(const UpdateTrailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateTrailOutcome()>>(
+			[this, request]()
+			{
+			return this->updateTrail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

actiontrail/src/model/CreateTrailRequest.cc

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/actiontrail/model/CreateTrailRequest.h>
+
+using AlibabaCloud::Actiontrail::Model::CreateTrailRequest;
+
+CreateTrailRequest::CreateTrailRequest() :
+	RpcServiceRequest("actiontrail", "2017-12-04", "CreateTrail")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateTrailRequest::~CreateTrailRequest()
+{}
+
+std::string CreateTrailRequest::getSlsProjectArn()const
+{
+	return slsProjectArn_;
+}
+
+void CreateTrailRequest::setSlsProjectArn(const std::string& slsProjectArn)
+{
+	slsProjectArn_ = slsProjectArn;
+	setParameter("SlsProjectArn", slsProjectArn);
+}
+
+std::string CreateTrailRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateTrailRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateTrailRequest::getSlsWriteRoleArn()const
+{
+	return slsWriteRoleArn_;
+}
+
+void CreateTrailRequest::setSlsWriteRoleArn(const std::string& slsWriteRoleArn)
+{
+	slsWriteRoleArn_ = slsWriteRoleArn;
+	setParameter("SlsWriteRoleArn", slsWriteRoleArn);
+}
+
+bool CreateTrailRequest::getIsOrganizationTrail()const
+{
+	return isOrganizationTrail_;
+}
+
+void CreateTrailRequest::setIsOrganizationTrail(bool isOrganizationTrail)
+{
+	isOrganizationTrail_ = isOrganizationTrail;
+	setParameter("IsOrganizationTrail", isOrganizationTrail ? "true" : "false");
+}
+
+std::string CreateTrailRequest::getOssKeyPrefix()const
+{
+	return ossKeyPrefix_;
+}
+
+void CreateTrailRequest::setOssKeyPrefix(const std::string& ossKeyPrefix)
+{
+	ossKeyPrefix_ = ossKeyPrefix;
+	setParameter("OssKeyPrefix", ossKeyPrefix);
+}
+
+std::string CreateTrailRequest::getMnsTopicArn()const
+{
+	return mnsTopicArn_;
+}
+
+void CreateTrailRequest::setMnsTopicArn(const std::string& mnsTopicArn)
+{
+	mnsTopicArn_ = mnsTopicArn;
+	setParameter("MnsTopicArn", mnsTopicArn);
+}
+
+std::string CreateTrailRequest::getRoleName()const
+{
+	return roleName_;
+}
+
+void CreateTrailRequest::setRoleName(const std::string& roleName)
+{
+	roleName_ = roleName;
+	setParameter("RoleName", roleName);
+}
+
+std::string CreateTrailRequest::getEventRW()const
+{
+	return eventRW_;
+}
+
+void CreateTrailRequest::setEventRW(const std::string& eventRW)
+{
+	eventRW_ = eventRW;
+	setParameter("EventRW", eventRW);
+}
+
+std::string CreateTrailRequest::getName()const
+{
+	return name_;
+}
+
+void CreateTrailRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string CreateTrailRequest::getOssBucketName()const
+{
+	return ossBucketName_;
+}
+
+void CreateTrailRequest::setOssBucketName(const std::string& ossBucketName)
+{
+	ossBucketName_ = ossBucketName;
+	setParameter("OssBucketName", ossBucketName);
+}
+
+std::string CreateTrailRequest::getTrailRegion()const
+{
+	return trailRegion_;
+}
+
+void CreateTrailRequest::setTrailRegion(const std::string& trailRegion)
+{
+	trailRegion_ = trailRegion;
+	setParameter("TrailRegion", trailRegion);
+}
+

actiontrail/src/model/CreateTrailResult.cc

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/actiontrail/model/CreateTrailResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Actiontrail;
+using namespace AlibabaCloud::Actiontrail::Model;
+
+CreateTrailResult::CreateTrailResult() :
+	ServiceResult()
+{}
+
+CreateTrailResult::CreateTrailResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateTrailResult::~CreateTrailResult()
+{}
+
+void CreateTrailResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
+	if(!value["HomeRegion"].isNull())
+		homeRegion_ = value["HomeRegion"].asString();
+	if(!value["OssBucketName"].isNull())
+		ossBucketName_ = value["OssBucketName"].asString();
+	if(!value["OssKeyPrefix"].isNull())
+		ossKeyPrefix_ = value["OssKeyPrefix"].asString();
+	if(!value["RoleName"].isNull())
+		roleName_ = value["RoleName"].asString();
+	if(!value["SlsProjectArn"].isNull())
+		slsProjectArn_ = value["SlsProjectArn"].asString();
+	if(!value["SlsWriteRoleArn"].isNull())
+		slsWriteRoleArn_ = value["SlsWriteRoleArn"].asString();
+	if(!value["EventRW"].isNull())
+		eventRW_ = value["EventRW"].asString();
+	if(!value["TrailRegion"].isNull())
+		trailRegion_ = value["TrailRegion"].asString();
+	if(!value["MnsTopicArn"].isNull())
+		mnsTopicArn_ = value["MnsTopicArn"].asString();
+
+}
+
+std::string CreateTrailResult::getSlsProjectArn()const
+{
+	return slsProjectArn_;
+}
+
+std::string CreateTrailResult::getMnsTopicArn()const
+{
+	return mnsTopicArn_;
+}
+
+std::string CreateTrailResult::getRoleName()const
+{
+	return roleName_;
+}
+
+std::string CreateTrailResult::getEventRW()const
+{
+	return eventRW_;
+}
+
+std::string CreateTrailResult::getHomeRegion()const
+{
+	return homeRegion_;
+}
+
+std::string CreateTrailResult::getOssKeyPrefix()const
+{
+	return ossKeyPrefix_;
+}
+
+std::string CreateTrailResult::getOssBucketName()const
+{
+	return ossBucketName_;
+}
+
+std::string CreateTrailResult::getSlsWriteRoleArn()const
+{
+	return slsWriteRoleArn_;
+}
+
+std::string CreateTrailResult::getTrailRegion()const
+{
+	return trailRegion_;
+}
+
+std::string CreateTrailResult::getName()const
+{
+	return name_;
+}
+

actiontrail/src/model/DeleteTrailRequest.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/actiontrail/model/DeleteTrailRequest.h>
+
+using AlibabaCloud::Actiontrail::Model::DeleteTrailRequest;
+
+DeleteTrailRequest::DeleteTrailRequest() :
+	RpcServiceRequest("actiontrail", "2017-12-04", "DeleteTrail")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteTrailRequest::~DeleteTrailRequest()
+{}
+
+std::string DeleteTrailRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteTrailRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DeleteTrailRequest::getName()const
+{
+	return name_;
+}
+
+void DeleteTrailRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+

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

actiontrail/src/model/DescribeRegionsRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/actiontrail/model/DescribeRegionsRequest.h>
+
+using AlibabaCloud::Actiontrail::Model::DescribeRegionsRequest;
+
+DescribeRegionsRequest::DescribeRegionsRequest() :
+	RpcServiceRequest("actiontrail", "2017-12-04", "DescribeRegions")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeRegionsRequest::~DescribeRegionsRequest()
+{}
+
+std::string DescribeRegionsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeRegionsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

actiontrail/src/model/DescribeRegionsResult.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/actiontrail/model/DescribeRegionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Actiontrail;
+using namespace AlibabaCloud::Actiontrail::Model;
+
+DescribeRegionsResult::DescribeRegionsResult() :
+	ServiceResult()
+{}
+
+DescribeRegionsResult::DescribeRegionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeRegionsResult::~DescribeRegionsResult()
+{}
+
+void DescribeRegionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto regionsNode = value["Regions"];
+	auto allRegionNode = regionsNode["Region"]["RegionItem"];
+	for (auto regionsNodeRegionRegionItem : allRegionNode)
+	{
+		Regions::RegionItem regionItemObject;
+		if(!regionsNodeRegionRegionItem["RegionId"].isNull())
+			regionItemObject.regionId = regionsNodeRegionRegionItem["RegionId"].asString();
+		regions_.region.push_back(regionItemObject);
+	}
+
+}
+
+DescribeRegionsResult::Regions DescribeRegionsResult::getRegions()const
+{
+	return regions_;
+}
+

actiontrail/src/model/DescribeTrailsRequest.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/actiontrail/model/DescribeTrailsRequest.h>
+
+using AlibabaCloud::Actiontrail::Model::DescribeTrailsRequest;
+
+DescribeTrailsRequest::DescribeTrailsRequest() :
+	RpcServiceRequest("actiontrail", "2017-12-04", "DescribeTrails")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeTrailsRequest::~DescribeTrailsRequest()
+{}
+
+bool DescribeTrailsRequest::getIncludeShadowTrails()const
+{
+	return includeShadowTrails_;
+}
+
+void DescribeTrailsRequest::setIncludeShadowTrails(bool includeShadowTrails)
+{
+	includeShadowTrails_ = includeShadowTrails;
+	setParameter("IncludeShadowTrails", includeShadowTrails ? "true" : "false");
+}
+
+std::string DescribeTrailsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeTrailsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeTrailsRequest::getNameList()const
+{
+	return nameList_;
+}
+
+void DescribeTrailsRequest::setNameList(const std::string& nameList)
+{
+	nameList_ = nameList;
+	setParameter("NameList", nameList);
+}
+

actiontrail/src/model/DescribeTrailsResult.cc

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/actiontrail/model/DescribeTrailsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Actiontrail;
+using namespace AlibabaCloud::Actiontrail::Model;
+
+DescribeTrailsResult::DescribeTrailsResult() :
+	ServiceResult()
+{}
+
+DescribeTrailsResult::DescribeTrailsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeTrailsResult::~DescribeTrailsResult()
+{}
+
+void DescribeTrailsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTrailListNode = value["TrailList"]["TrailListItem"];
+	for (auto valueTrailListTrailListItem : allTrailListNode)
+	{
+		TrailListItem trailListObject;
+		if(!valueTrailListTrailListItem["Name"].isNull())
+			trailListObject.name = valueTrailListTrailListItem["Name"].asString();
+		if(!valueTrailListTrailListItem["HomeRegion"].isNull())
+			trailListObject.homeRegion = valueTrailListTrailListItem["HomeRegion"].asString();
+		if(!valueTrailListTrailListItem["RoleName"].isNull())
+			trailListObject.roleName = valueTrailListTrailListItem["RoleName"].asString();
+		if(!valueTrailListTrailListItem["OssBucketName"].isNull())
+			trailListObject.ossBucketName = valueTrailListTrailListItem["OssBucketName"].asString();
+		if(!valueTrailListTrailListItem["OssKeyPrefix"].isNull())
+			trailListObject.ossKeyPrefix = valueTrailListTrailListItem["OssKeyPrefix"].asString();
+		if(!valueTrailListTrailListItem["EventRW"].isNull())
+			trailListObject.eventRW = valueTrailListTrailListItem["EventRW"].asString();
+		if(!valueTrailListTrailListItem["SlsWriteRoleArn"].isNull())
+			trailListObject.slsWriteRoleArn = valueTrailListTrailListItem["SlsWriteRoleArn"].asString();
+		if(!valueTrailListTrailListItem["SlsProjectArn"].isNull())
+			trailListObject.slsProjectArn = valueTrailListTrailListItem["SlsProjectArn"].asString();
+		if(!valueTrailListTrailListItem["Status"].isNull())
+			trailListObject.status = valueTrailListTrailListItem["Status"].asString();
+		if(!valueTrailListTrailListItem["TrailRegion"].isNull())
+			trailListObject.trailRegion = valueTrailListTrailListItem["TrailRegion"].asString();
+		if(!valueTrailListTrailListItem["CreateTime"].isNull())
+			trailListObject.createTime = valueTrailListTrailListItem["CreateTime"].asString();
+		if(!valueTrailListTrailListItem["UpdateTime"].isNull())
+			trailListObject.updateTime = valueTrailListTrailListItem["UpdateTime"].asString();
+		if(!valueTrailListTrailListItem["StartLoggingTime"].isNull())
+			trailListObject.startLoggingTime = valueTrailListTrailListItem["StartLoggingTime"].asString();
+		if(!valueTrailListTrailListItem["StopLoggingTime"].isNull())
+			trailListObject.stopLoggingTime = valueTrailListTrailListItem["StopLoggingTime"].asString();
+		if(!valueTrailListTrailListItem["MnsTopicArn"].isNull())
+			trailListObject.mnsTopicArn = valueTrailListTrailListItem["MnsTopicArn"].asString();
+		if(!valueTrailListTrailListItem["IsOrganizationTrail"].isNull())
+			trailListObject.isOrganizationTrail = valueTrailListTrailListItem["IsOrganizationTrail"].asString() == "true";
+		trailList_.push_back(trailListObject);
+	}
+
+}
+
+std::vector<DescribeTrailsResult::TrailListItem> DescribeTrailsResult::getTrailList()const
+{
+	return trailList_;
+}
+

actiontrail/src/model/GetTrailStatusRequest.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/actiontrail/model/GetTrailStatusRequest.h>
+
+using AlibabaCloud::Actiontrail::Model::GetTrailStatusRequest;
+
+GetTrailStatusRequest::GetTrailStatusRequest() :
+	RpcServiceRequest("actiontrail", "2017-12-04", "GetTrailStatus")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetTrailStatusRequest::~GetTrailStatusRequest()
+{}
+
+std::string GetTrailStatusRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void GetTrailStatusRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string GetTrailStatusRequest::getName()const
+{
+	return name_;
+}
+
+void GetTrailStatusRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+bool GetTrailStatusRequest::getIsOrganizationTrail()const
+{
+	return isOrganizationTrail_;
+}
+
+void GetTrailStatusRequest::setIsOrganizationTrail(bool isOrganizationTrail)
+{
+	isOrganizationTrail_ = isOrganizationTrail;
+	setParameter("IsOrganizationTrail", isOrganizationTrail ? "true" : "false");
+}
+

actiontrail/src/model/GetTrailStatusResult.cc

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

actiontrail/src/model/LookupEventsRequest.cc

@@ -0,0 +1,194 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/actiontrail/model/LookupEventsRequest.h>
+
+using AlibabaCloud::Actiontrail::Model::LookupEventsRequest;
+
+LookupEventsRequest::LookupEventsRequest() :
+	RpcServiceRequest("actiontrail", "2017-12-04", "LookupEvents")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+LookupEventsRequest::~LookupEventsRequest()
+{}
+
+std::string LookupEventsRequest::getRequest()const
+{
+	return request_;
+}
+
+void LookupEventsRequest::setRequest(const std::string& request)
+{
+	request_ = request;
+	setParameter("Request", request);
+}
+
+std::string LookupEventsRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void LookupEventsRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string LookupEventsRequest::getEventName()const
+{
+	return eventName_;
+}
+
+void LookupEventsRequest::setEventName(const std::string& eventName)
+{
+	eventName_ = eventName;
+	setParameter("EventName", eventName);
+}
+
+std::string LookupEventsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void LookupEventsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string LookupEventsRequest::getNextToken()const
+{
+	return nextToken_;
+}
+
+void LookupEventsRequest::setNextToken(const std::string& nextToken)
+{
+	nextToken_ = nextToken;
+	setParameter("NextToken", nextToken);
+}
+
+std::string LookupEventsRequest::getServiceName()const
+{
+	return serviceName_;
+}
+
+void LookupEventsRequest::setServiceName(const std::string& serviceName)
+{
+	serviceName_ = serviceName;
+	setParameter("ServiceName", serviceName);
+}
+
+std::string LookupEventsRequest::getEvent()const
+{
+	return event_;
+}
+
+void LookupEventsRequest::setEvent(const std::string& event)
+{
+	event_ = event;
+	setParameter("Event", event);
+}
+
+std::string LookupEventsRequest::getEventAccessKeyId()const
+{
+	return eventAccessKeyId_;
+}
+
+void LookupEventsRequest::setEventAccessKeyId(const std::string& eventAccessKeyId)
+{
+	eventAccessKeyId_ = eventAccessKeyId;
+	setParameter("EventAccessKeyId", eventAccessKeyId);
+}
+
+std::string LookupEventsRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void LookupEventsRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string LookupEventsRequest::getEventRW()const
+{
+	return eventRW_;
+}
+
+void LookupEventsRequest::setEventRW(const std::string& eventRW)
+{
+	eventRW_ = eventRW;
+	setParameter("EventRW", eventRW);
+}
+
+std::string LookupEventsRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void LookupEventsRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+
+std::string LookupEventsRequest::getMaxResults()const
+{
+	return maxResults_;
+}
+
+void LookupEventsRequest::setMaxResults(const std::string& maxResults)
+{
+	maxResults_ = maxResults;
+	setParameter("MaxResults", maxResults);
+}
+
+std::string LookupEventsRequest::getEventType()const
+{
+	return eventType_;
+}
+
+void LookupEventsRequest::setEventType(const std::string& eventType)
+{
+	eventType_ = eventType;
+	setParameter("EventType", eventType);
+}
+
+std::string LookupEventsRequest::getResourceName()const
+{
+	return resourceName_;
+}
+
+void LookupEventsRequest::setResourceName(const std::string& resourceName)
+{
+	resourceName_ = resourceName;
+	setParameter("ResourceName", resourceName);
+}
+
+std::string LookupEventsRequest::getUser()const
+{
+	return user_;
+}
+
+void LookupEventsRequest::setUser(const std::string& user)
+{
+	user_ = user;
+	setParameter("User", user);
+}
+

actiontrail/src/model/LookupEventsResult.cc

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/actiontrail/model/LookupEventsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Actiontrail;
+using namespace AlibabaCloud::Actiontrail::Model;
+
+LookupEventsResult::LookupEventsResult() :
+	ServiceResult()
+{}
+
+LookupEventsResult::LookupEventsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+LookupEventsResult::~LookupEventsResult()
+{}
+
+void LookupEventsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allEvents = value["Events"]["Events"];
+	for (const auto &item : allEvents)
+		events_.push_back(item.asString());
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+
+}
+
+std::string LookupEventsResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+std::string LookupEventsResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::vector<std::string> LookupEventsResult::getEvents()const
+{
+	return events_;
+}
+
+std::string LookupEventsResult::getStartTime()const
+{
+	return startTime_;
+}
+

actiontrail/src/model/StartLoggingRequest.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/actiontrail/model/StartLoggingRequest.h>
+
+using AlibabaCloud::Actiontrail::Model::StartLoggingRequest;
+
+StartLoggingRequest::StartLoggingRequest() :
+	RpcServiceRequest("actiontrail", "2017-12-04", "StartLogging")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+StartLoggingRequest::~StartLoggingRequest()
+{}
+
+std::string StartLoggingRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void StartLoggingRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string StartLoggingRequest::getName()const
+{
+	return name_;
+}
+
+void StartLoggingRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+

actiontrail/src/model/StartLoggingResult.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/actiontrail/model/StartLoggingResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Actiontrail;
+using namespace AlibabaCloud::Actiontrail::Model;
+
+StartLoggingResult::StartLoggingResult() :
+	ServiceResult()
+{}
+
+StartLoggingResult::StartLoggingResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+StartLoggingResult::~StartLoggingResult()
+{}
+
+void StartLoggingResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Param"].isNull())
+		param_ = value["Param"].asString();
+	if(!value["Result"].isNull())
+		result_ = value["Result"].asString();
+
+}
+
+std::string StartLoggingResult::getParam()const
+{
+	return param_;
+}
+
+std::string StartLoggingResult::getResult()const
+{
+	return result_;
+}
+

actiontrail/src/model/StopLoggingRequest.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/actiontrail/model/StopLoggingRequest.h>
+
+using AlibabaCloud::Actiontrail::Model::StopLoggingRequest;
+
+StopLoggingRequest::StopLoggingRequest() :
+	RpcServiceRequest("actiontrail", "2017-12-04", "StopLogging")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+StopLoggingRequest::~StopLoggingRequest()
+{}
+
+std::string StopLoggingRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void StopLoggingRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string StopLoggingRequest::getName()const
+{
+	return name_;
+}
+
+void StopLoggingRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+

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

actiontrail/src/model/UpdateTrailRequest.cc

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/actiontrail/model/UpdateTrailRequest.h>
+
+using AlibabaCloud::Actiontrail::Model::UpdateTrailRequest;
+
+UpdateTrailRequest::UpdateTrailRequest() :
+	RpcServiceRequest("actiontrail", "2017-12-04", "UpdateTrail")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateTrailRequest::~UpdateTrailRequest()
+{}
+
+std::string UpdateTrailRequest::getSlsProjectArn()const
+{
+	return slsProjectArn_;
+}
+
+void UpdateTrailRequest::setSlsProjectArn(const std::string& slsProjectArn)
+{
+	slsProjectArn_ = slsProjectArn;
+	setParameter("SlsProjectArn", slsProjectArn);
+}
+
+std::string UpdateTrailRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void UpdateTrailRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string UpdateTrailRequest::getSlsWriteRoleArn()const
+{
+	return slsWriteRoleArn_;
+}
+
+void UpdateTrailRequest::setSlsWriteRoleArn(const std::string& slsWriteRoleArn)
+{
+	slsWriteRoleArn_ = slsWriteRoleArn;
+	setParameter("SlsWriteRoleArn", slsWriteRoleArn);
+}
+
+std::string UpdateTrailRequest::getOssKeyPrefix()const
+{
+	return ossKeyPrefix_;
+}
+
+void UpdateTrailRequest::setOssKeyPrefix(const std::string& ossKeyPrefix)
+{
+	ossKeyPrefix_ = ossKeyPrefix;
+	setParameter("OssKeyPrefix", ossKeyPrefix);
+}
+
+std::string UpdateTrailRequest::getMnsTopicArn()const
+{
+	return mnsTopicArn_;
+}
+
+void UpdateTrailRequest::setMnsTopicArn(const std::string& mnsTopicArn)
+{
+	mnsTopicArn_ = mnsTopicArn;
+	setParameter("MnsTopicArn", mnsTopicArn);
+}
+
+std::string UpdateTrailRequest::getRoleName()const
+{
+	return roleName_;
+}
+
+void UpdateTrailRequest::setRoleName(const std::string& roleName)
+{
+	roleName_ = roleName;
+	setParameter("RoleName", roleName);
+}
+
+std::string UpdateTrailRequest::getEventRW()const
+{
+	return eventRW_;
+}
+
+void UpdateTrailRequest::setEventRW(const std::string& eventRW)
+{
+	eventRW_ = eventRW;
+	setParameter("EventRW", eventRW);
+}
+
+std::string UpdateTrailRequest::getName()const
+{
+	return name_;
+}
+
+void UpdateTrailRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string UpdateTrailRequest::getOssBucketName()const
+{
+	return ossBucketName_;
+}
+
+void UpdateTrailRequest::setOssBucketName(const std::string& ossBucketName)
+{
+	ossBucketName_ = ossBucketName;
+	setParameter("OssBucketName", ossBucketName);
+}
+
+std::string UpdateTrailRequest::getTrailRegion()const
+{
+	return trailRegion_;
+}
+
+void UpdateTrailRequest::setTrailRegion(const std::string& trailRegion)
+{
+	trailRegion_ = trailRegion;
+	setParameter("TrailRegion", trailRegion);
+}
+

actiontrail/src/model/UpdateTrailResult.cc

@@ -0,0 +1,114 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/actiontrail/model/UpdateTrailResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Actiontrail;
+using namespace AlibabaCloud::Actiontrail::Model;
+
+UpdateTrailResult::UpdateTrailResult() :
+	ServiceResult()
+{}
+
+UpdateTrailResult::UpdateTrailResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UpdateTrailResult::~UpdateTrailResult()
+{}
+
+void UpdateTrailResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
+	if(!value["HomeRegion"].isNull())
+		homeRegion_ = value["HomeRegion"].asString();
+	if(!value["OssBucketName"].isNull())
+		ossBucketName_ = value["OssBucketName"].asString();
+	if(!value["OssKeyPrefix"].isNull())
+		ossKeyPrefix_ = value["OssKeyPrefix"].asString();
+	if(!value["RoleName"].isNull())
+		roleName_ = value["RoleName"].asString();
+	if(!value["SlsProjectArn"].isNull())
+		slsProjectArn_ = value["SlsProjectArn"].asString();
+	if(!value["SlsWriteRoleArn"].isNull())
+		slsWriteRoleArn_ = value["SlsWriteRoleArn"].asString();
+	if(!value["EventRW"].isNull())
+		eventRW_ = value["EventRW"].asString();
+	if(!value["TrailRegion"].isNull())
+		trailRegion_ = value["TrailRegion"].asString();
+	if(!value["MnsTopicArn"].isNull())
+		mnsTopicArn_ = value["MnsTopicArn"].asString();
+
+}
+
+std::string UpdateTrailResult::getSlsProjectArn()const
+{
+	return slsProjectArn_;
+}
+
+std::string UpdateTrailResult::getMnsTopicArn()const
+{
+	return mnsTopicArn_;
+}
+
+std::string UpdateTrailResult::getRoleName()const
+{
+	return roleName_;
+}
+
+std::string UpdateTrailResult::getEventRW()const
+{
+	return eventRW_;
+}
+
+std::string UpdateTrailResult::getHomeRegion()const
+{
+	return homeRegion_;
+}
+
+std::string UpdateTrailResult::getOssKeyPrefix()const
+{
+	return ossKeyPrefix_;
+}
+
+std::string UpdateTrailResult::getOssBucketName()const
+{
+	return ossBucketName_;
+}
+
+std::string UpdateTrailResult::getSlsWriteRoleArn()const
+{
+	return slsWriteRoleArn_;
+}
+
+std::string UpdateTrailResult::getTrailRegion()const
+{
+	return trailRegion_;
+}
+
+std::string UpdateTrailResult::getName()const
+{
+	return name_;
+}
+

alimt/include/alibabacloud/alimt/model/GetImageTranslateResult.h

@@ -35,6 +35,7 @@ namespace AlibabaCloud
 				struct Data
 				{
 					std::string orc;
+					std::string pictureEditor;
 					std::string url;
 				};
 

alimt/src/model/GetImageTranslateResult.cc

@@ -44,6 +44,8 @@ void GetImageTranslateResult::parse(const std::string &payload)
 		data_.url = dataNode["Url"].asString();
 	if(!dataNode["Orc"].isNull())
 		data_.orc = dataNode["Orc"].asString();
+	if(!dataNode["PictureEditor"].isNull())
+		data_.pictureEditor = dataNode["PictureEditor"].asString();
 	if(!value["Code"].isNull())
 		code_ = std::stoi(value["Code"].asString());
 	if(!value["Message"].isNull())

codeup/CMakeLists.txt

@@ -57,6 +57,8 @@ set(codeup_public_header_model
 	include/alibabacloud/codeup/model/GetCodeupOrganizationResult.h
 	include/alibabacloud/codeup/model/GetFileBlobsRequest.h
 	include/alibabacloud/codeup/model/GetFileBlobsResult.h
+	include/alibabacloud/codeup/model/GetGroupDetailRequest.h
+	include/alibabacloud/codeup/model/GetGroupDetailResult.h
 	include/alibabacloud/codeup/model/GetProjectMemberRequest.h
 	include/alibabacloud/codeup/model/GetProjectMemberResult.h
 	include/alibabacloud/codeup/model/GetRepositoryInfoRequest.h
@@ -67,6 +69,8 @@ set(codeup_public_header_model
 	include/alibabacloud/codeup/model/ListGroupRepositoriesResult.h
 	include/alibabacloud/codeup/model/ListGroupsRequest.h
 	include/alibabacloud/codeup/model/ListGroupsResult.h
+	include/alibabacloud/codeup/model/ListRepositoryBranchesRequest.h
+	include/alibabacloud/codeup/model/ListRepositoryBranchesResult.h
 	include/alibabacloud/codeup/model/ListRepositoryMemberRequest.h
 	include/alibabacloud/codeup/model/ListRepositoryMemberResult.h
 	include/alibabacloud/codeup/model/ListRepositoryTreeRequest.h
@@ -118,6 +122,8 @@ set(codeup_src
 	src/model/GetCodeupOrganizationResult.cc
 	src/model/GetFileBlobsRequest.cc
 	src/model/GetFileBlobsResult.cc
+	src/model/GetGroupDetailRequest.cc
+	src/model/GetGroupDetailResult.cc
 	src/model/GetProjectMemberRequest.cc
 	src/model/GetProjectMemberResult.cc
 	src/model/GetRepositoryInfoRequest.cc
@@ -128,6 +134,8 @@ set(codeup_src
 	src/model/ListGroupRepositoriesResult.cc
 	src/model/ListGroupsRequest.cc
 	src/model/ListGroupsResult.cc
+	src/model/ListRepositoryBranchesRequest.cc
+	src/model/ListRepositoryBranchesResult.cc
 	src/model/ListRepositoryMemberRequest.cc
 	src/model/ListRepositoryMemberResult.cc
 	src/model/ListRepositoryTreeRequest.cc

codeup/include/alibabacloud/codeup/CodeupClient.h

@@ -58,6 +58,8 @@
 #include "model/GetCodeupOrganizationResult.h"
 #include "model/GetFileBlobsRequest.h"
 #include "model/GetFileBlobsResult.h"
+#include "model/GetGroupDetailRequest.h"
+#include "model/GetGroupDetailResult.h"
 #include "model/GetProjectMemberRequest.h"
 #include "model/GetProjectMemberResult.h"
 #include "model/GetRepositoryInfoRequest.h"
@@ -68,6 +70,8 @@
 #include "model/ListGroupRepositoriesResult.h"
 #include "model/ListGroupsRequest.h"
 #include "model/ListGroupsResult.h"
+#include "model/ListRepositoryBranchesRequest.h"
+#include "model/ListRepositoryBranchesResult.h"
 #include "model/ListRepositoryMemberRequest.h"
 #include "model/ListRepositoryMemberResult.h"
 #include "model/ListRepositoryTreeRequest.h"
@@ -143,6 +147,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetFileBlobsResult> GetFileBlobsOutcome;
 			typedef std::future<GetFileBlobsOutcome> GetFileBlobsOutcomeCallable;
 			typedef std::function<void(const CodeupClient*, const Model::GetFileBlobsRequest&, const GetFileBlobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetFileBlobsAsyncHandler;
+			typedef Outcome<Error, Model::GetGroupDetailResult> GetGroupDetailOutcome;
+			typedef std::future<GetGroupDetailOutcome> GetGroupDetailOutcomeCallable;
+			typedef std::function<void(const CodeupClient*, const Model::GetGroupDetailRequest&, const GetGroupDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetGroupDetailAsyncHandler;
 			typedef Outcome<Error, Model::GetProjectMemberResult> GetProjectMemberOutcome;
 			typedef std::future<GetProjectMemberOutcome> GetProjectMemberOutcomeCallable;
 			typedef std::function<void(const CodeupClient*, const Model::GetProjectMemberRequest&, const GetProjectMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetProjectMemberAsyncHandler;
@@ -158,6 +165,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListGroupsResult> ListGroupsOutcome;
 			typedef std::future<ListGroupsOutcome> ListGroupsOutcomeCallable;
 			typedef std::function<void(const CodeupClient*, const Model::ListGroupsRequest&, const ListGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ListRepositoryBranchesResult> ListRepositoryBranchesOutcome;
+			typedef std::future<ListRepositoryBranchesOutcome> ListRepositoryBranchesOutcomeCallable;
+			typedef std::function<void(const CodeupClient*, const Model::ListRepositoryBranchesRequest&, const ListRepositoryBranchesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRepositoryBranchesAsyncHandler;
 			typedef Outcome<Error, Model::ListRepositoryMemberResult> ListRepositoryMemberOutcome;
 			typedef std::future<ListRepositoryMemberOutcome> ListRepositoryMemberOutcomeCallable;
 			typedef std::function<void(const CodeupClient*, const Model::ListRepositoryMemberRequest&, const ListRepositoryMemberOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRepositoryMemberAsyncHandler;
@@ -235,6 +245,9 @@ namespace AlibabaCloud
 			GetFileBlobsOutcome getFileBlobs(const Model::GetFileBlobsRequest &request)const;
 			void getFileBlobsAsync(const Model::GetFileBlobsRequest& request, const GetFileBlobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetFileBlobsOutcomeCallable getFileBlobsCallable(const Model::GetFileBlobsRequest& request) const;
+			GetGroupDetailOutcome getGroupDetail(const Model::GetGroupDetailRequest &request)const;
+			void getGroupDetailAsync(const Model::GetGroupDetailRequest& request, const GetGroupDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetGroupDetailOutcomeCallable getGroupDetailCallable(const Model::GetGroupDetailRequest& request) const;
 			GetProjectMemberOutcome getProjectMember(const Model::GetProjectMemberRequest &request)const;
 			void getProjectMemberAsync(const Model::GetProjectMemberRequest& request, const GetProjectMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetProjectMemberOutcomeCallable getProjectMemberCallable(const Model::GetProjectMemberRequest& request) const;
@@ -250,6 +263,9 @@ namespace AlibabaCloud
 			ListGroupsOutcome listGroups(const Model::ListGroupsRequest &request)const;
 			void listGroupsAsync(const Model::ListGroupsRequest& request, const ListGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListGroupsOutcomeCallable listGroupsCallable(const Model::ListGroupsRequest& request) const;
+			ListRepositoryBranchesOutcome listRepositoryBranches(const Model::ListRepositoryBranchesRequest &request)const;
+			void listRepositoryBranchesAsync(const Model::ListRepositoryBranchesRequest& request, const ListRepositoryBranchesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListRepositoryBranchesOutcomeCallable listRepositoryBranchesCallable(const Model::ListRepositoryBranchesRequest& request) const;
 			ListRepositoryMemberOutcome listRepositoryMember(const Model::ListRepositoryMemberRequest &request)const;
 			void listRepositoryMemberAsync(const Model::ListRepositoryMemberRequest& request, const ListRepositoryMemberAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListRepositoryMemberOutcomeCallable listRepositoryMemberCallable(const Model::ListRepositoryMemberRequest& request) const;

codeup/include/alibabacloud/codeup/model/GetGroupDetailRequest.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_CODEUP_MODEL_GETGROUPDETAILREQUEST_H_
+#define ALIBABACLOUD_CODEUP_MODEL_GETGROUPDETAILREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/codeup/CodeupExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Codeup
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CODEUP_EXPORT GetGroupDetailRequest : public RoaServiceRequest
+			{
+
+			public:
+				GetGroupDetailRequest();
+				~GetGroupDetailRequest();
+
+				std::string getOrganizationId()const;
+				void setOrganizationId(const std::string& organizationId);
+				std::string getSubUserId()const;
+				void setSubUserId(const std::string& subUserId);
+				long getGroupId()const;
+				void setGroupId(long groupId);
+				std::string getAccessToken()const;
+				void setAccessToken(const std::string& accessToken);
+
+            private:
+				std::string organizationId_;
+				std::string subUserId_;
+				long groupId_;
+				std::string accessToken_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CODEUP_MODEL_GETGROUPDETAILREQUEST_H_

codeup/include/alibabacloud/codeup/model/GetGroupDetailResult.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_CODEUP_MODEL_GETGROUPDETAILRESULT_H_
+#define ALIBABACLOUD_CODEUP_MODEL_GETGROUPDETAILRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/codeup/CodeupExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Codeup
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CODEUP_EXPORT GetGroupDetailResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					std::string path;
+					std::string pathWithNamespace;
+					long parentId;
+					std::string type;
+					std::string description;
+					std::string avatarUrl;
+					long ownerId;
+					std::string webUrl;
+					std::string nameWithNamespace;
+					std::string visibilityLevel;
+					long id;
+					std::string name;
+				};
+
+
+				GetGroupDetailResult();
+				explicit GetGroupDetailResult(const std::string &payload);
+				~GetGroupDetailResult();
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CODEUP_MODEL_GETGROUPDETAILRESULT_H_

codeup/include/alibabacloud/codeup/model/ListGroupMemberResult.h

@@ -46,6 +46,7 @@ namespace AlibabaCloud
 				ListGroupMemberResult();
 				explicit ListGroupMemberResult(const std::string &payload);
 				~ListGroupMemberResult();
+				long getTotal()const;
 				std::string getErrorCode()const;
 				std::string getErrorMessage()const;
 				bool getSuccess()const;
@@ -54,6 +55,7 @@ namespace AlibabaCloud
 			protected:
 				void parse(const std::string &payload);
 			private:
+				long total_;
 				std::string errorCode_;
 				std::string errorMessage_;
 				bool success_;

codeup/include/alibabacloud/codeup/model/ListGroupRepositoriesResult.h

@@ -56,6 +56,7 @@ namespace AlibabaCloud
 				ListGroupRepositoriesResult();
 				explicit ListGroupRepositoriesResult(const std::string &payload);
 				~ListGroupRepositoriesResult();
+				long getTotal()const;
 				std::string getErrorCode()const;
 				std::string getErrorMessage()const;
 				bool getSuccess()const;
@@ -64,6 +65,7 @@ namespace AlibabaCloud
 			protected:
 				void parse(const std::string &payload);
 			private:
+				long total_;
 				std::string errorCode_;
 				std::string errorMessage_;
 				bool success_;

codeup/include/alibabacloud/codeup/model/ListGroupsResult.h

@@ -54,6 +54,7 @@ namespace AlibabaCloud
 				ListGroupsResult();
 				explicit ListGroupsResult(const std::string &payload);
 				~ListGroupsResult();
+				long getTotal()const;
 				std::string getErrorCode()const;
 				std::string getErrorMessage()const;
 				bool getSuccess()const;
@@ -62,6 +63,7 @@ namespace AlibabaCloud
 			protected:
 				void parse(const std::string &payload);
 			private:
+				long total_;
 				std::string errorCode_;
 				std::string errorMessage_;
 				bool success_;

codeup/include/alibabacloud/codeup/model/ListRepositoryBranchesRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CODEUP_MODEL_LISTREPOSITORYBRANCHESREQUEST_H_
+#define ALIBABACLOUD_CODEUP_MODEL_LISTREPOSITORYBRANCHESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <alibabacloud/codeup/CodeupExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Codeup
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CODEUP_EXPORT ListRepositoryBranchesRequest : public RoaServiceRequest
+			{
+
+			public:
+				ListRepositoryBranchesRequest();
+				~ListRepositoryBranchesRequest();
+
+				std::string getOrganizationId()const;
+				void setOrganizationId(const std::string& organizationId);
+				std::string getSearch()const;
+				void setSearch(const std::string& search);
+				std::string getSubUserId()const;
+				void setSubUserId(const std::string& subUserId);
+				long getPageSize()const;
+				void setPageSize(long pageSize);
+				std::string getAccessToken()const;
+				void setAccessToken(const std::string& accessToken);
+				long getPage()const;
+				void setPage(long page);
+				long getProjectId()const;
+				void setProjectId(long projectId);
+
+            private:
+				std::string organizationId_;
+				std::string search_;
+				std::string subUserId_;
+				long pageSize_;
+				std::string accessToken_;
+				long page_;
+				long projectId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CODEUP_MODEL_LISTREPOSITORYBRANCHESREQUEST_H_

codeup/include/alibabacloud/codeup/model/ListRepositoryBranchesResult.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_CODEUP_MODEL_LISTREPOSITORYBRANCHESRESULT_H_
+#define ALIBABACLOUD_CODEUP_MODEL_LISTREPOSITORYBRANCHESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/codeup/CodeupExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Codeup
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CODEUP_EXPORT ListRepositoryBranchesResult : public ServiceResult
+			{
+			public:
+				struct ResultItem
+				{
+					struct CommitInfo
+					{
+						std::string authorName;
+						std::string message;
+						std::string authorDate;
+						std::string committedDate;
+						std::string committerEmail;
+						std::vector<std::string> parentIds;
+						std::string createdAt;
+						std::string shortId;
+						std::string title;
+						std::string id;
+						std::string authorEmail;
+						std::string committerName;
+					};
+					bool protectedBranch;
+					CommitInfo commitInfo;
+					std::string branchName;
+				};
+
+
+				ListRepositoryBranchesResult();
+				explicit ListRepositoryBranchesResult(const std::string &payload);
+				~ListRepositoryBranchesResult();
+				long getTotal()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+				std::vector<ResultItem> getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long total_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+				std::vector<ResultItem> result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CODEUP_MODEL_LISTREPOSITORYBRANCHESRESULT_H_

codeup/include/alibabacloud/codeup/model/ListRepositoryMemberResult.h

@@ -46,6 +46,7 @@ namespace AlibabaCloud
 				ListRepositoryMemberResult();
 				explicit ListRepositoryMemberResult(const std::string &payload);
 				~ListRepositoryMemberResult();
+				long getTotal()const;
 				std::string getErrorCode()const;
 				std::string getErrorMessage()const;
 				bool getSuccess()const;
@@ -54,6 +55,7 @@ namespace AlibabaCloud
 			protected:
 				void parse(const std::string &payload);
 			private:
+				long total_;
 				std::string errorCode_;
 				std::string errorMessage_;
 				bool success_;

codeup/src/CodeupClient.cc

@@ -699,6 +699,42 @@ CodeupClient::GetFileBlobsOutcomeCallable CodeupClient::getFileBlobsCallable(con
 	return task->get_future();
 }
 
+CodeupClient::GetGroupDetailOutcome CodeupClient::getGroupDetail(const GetGroupDetailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetGroupDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetGroupDetailOutcome(GetGroupDetailResult(outcome.result()));
+	else
+		return GetGroupDetailOutcome(outcome.error());
+}
+
+void CodeupClient::getGroupDetailAsync(const GetGroupDetailRequest& request, const GetGroupDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getGroupDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CodeupClient::GetGroupDetailOutcomeCallable CodeupClient::getGroupDetailCallable(const GetGroupDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetGroupDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->getGroupDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CodeupClient::GetProjectMemberOutcome CodeupClient::getProjectMember(const GetProjectMemberRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -879,6 +915,42 @@ CodeupClient::ListGroupsOutcomeCallable CodeupClient::listGroupsCallable(const L
 	return task->get_future();
 }
 
+CodeupClient::ListRepositoryBranchesOutcome CodeupClient::listRepositoryBranches(const ListRepositoryBranchesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListRepositoryBranchesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListRepositoryBranchesOutcome(ListRepositoryBranchesResult(outcome.result()));
+	else
+		return ListRepositoryBranchesOutcome(outcome.error());
+}
+
+void CodeupClient::listRepositoryBranchesAsync(const ListRepositoryBranchesRequest& request, const ListRepositoryBranchesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listRepositoryBranches(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CodeupClient::ListRepositoryBranchesOutcomeCallable CodeupClient::listRepositoryBranchesCallable(const ListRepositoryBranchesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListRepositoryBranchesOutcome()>>(
+			[this, request]()
+			{
+			return this->listRepositoryBranches(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CodeupClient::ListRepositoryMemberOutcome CodeupClient::listRepositoryMember(const ListRepositoryMemberRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

codeup/src/model/CreateMergeRequestResult.cc

@@ -112,18 +112,18 @@ void CreateMergeRequestResult::parse(const std::string &payload)
 			satisfiedCheckResultsItemObject.checkName = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItem["CheckName"].asString();
 		if(!approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItem["CheckType"].isNull())
 			satisfiedCheckResultsItemObject.checkType = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItem["CheckType"].asString();
-		auto allExtraUsersNode = allSatisfiedCheckResultsNode["ExtraUsers"]["ExtraUsersItem"];
-		for (auto allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem : allExtraUsersNode)
+		auto allExtraUsersNode = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItem["ExtraUsers"]["ExtraUsersItem"];
+		for (auto approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem : allExtraUsersNode)
 		{
 			Result::ApproveCheckResult::SatisfiedCheckResultsItem::ExtraUsersItem extraUsersObject;
-			if(!allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Id"].isNull())
-				extraUsersObject.id = std::stol(allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Id"].asString());
-			if(!allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["ExternUserId"].isNull())
-				extraUsersObject.externUserId = allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["ExternUserId"].asString();
-			if(!allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["AvatarUrl"].isNull())
-				extraUsersObject.avatarUrl = allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["AvatarUrl"].asString();
-			if(!allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Name"].isNull())
-				extraUsersObject.name = allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Name"].asString();
+			if(!approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["Id"].isNull())
+				extraUsersObject.id = std::stol(approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["Id"].asString());
+			if(!approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["ExternUserId"].isNull())
+				extraUsersObject.externUserId = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["ExternUserId"].asString();
+			if(!approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["AvatarUrl"].isNull())
+				extraUsersObject.avatarUrl = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["AvatarUrl"].asString();
+			if(!approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["Name"].isNull())
+				extraUsersObject.name = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["Name"].asString();
 			satisfiedCheckResultsItemObject.extraUsers.push_back(extraUsersObject);
 		}
 		auto allSatisfiedItems = value["SatisfiedItems"]["SatisfiedItems"];
@@ -144,18 +144,18 @@ void CreateMergeRequestResult::parse(const std::string &payload)
 			unsatisfiedCheckResultsItemObject.checkName = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItem["CheckName"].asString();
 		if(!approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItem["CheckType"].isNull())
 			unsatisfiedCheckResultsItemObject.checkType = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItem["CheckType"].asString();
-		auto allExtraUsers3Node = allUnsatisfiedCheckResultsNode["ExtraUsers"]["ExtraUsersItem"];
-		for (auto allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem : allExtraUsers3Node)
+		auto allExtraUsers3Node = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItem["ExtraUsers"]["ExtraUsersItem"];
+		for (auto approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem : allExtraUsers3Node)
 		{
 			Result::ApproveCheckResult::UnsatisfiedCheckResultsItem::ExtraUsersItem4 extraUsers3Object;
-			if(!allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Id"].isNull())
-				extraUsers3Object.id = std::stol(allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Id"].asString());
-			if(!allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["ExternUserId"].isNull())
-				extraUsers3Object.externUserId = allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["ExternUserId"].asString();
-			if(!allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["AvatarUrl"].isNull())
-				extraUsers3Object.avatarUrl = allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["AvatarUrl"].asString();
-			if(!allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Name"].isNull())
-				extraUsers3Object.name = allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Name"].asString();
+			if(!approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["Id"].isNull())
+				extraUsers3Object.id = std::stol(approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["Id"].asString());
+			if(!approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["ExternUserId"].isNull())
+				extraUsers3Object.externUserId = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["ExternUserId"].asString();
+			if(!approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["AvatarUrl"].isNull())
+				extraUsers3Object.avatarUrl = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["AvatarUrl"].asString();
+			if(!approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["Name"].isNull())
+				extraUsers3Object.name = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["Name"].asString();
 			unsatisfiedCheckResultsItemObject.extraUsers3.push_back(extraUsers3Object);
 		}
 		auto allSatisfiedItems1 = value["SatisfiedItems"]["SatisfiedItems"];

codeup/src/model/DeleteBranchRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Codeup::Model::DeleteBranchRequest;
 DeleteBranchRequest::DeleteBranchRequest() :
 	RoaServiceRequest("codeup", "2020-04-14")
 {
-	setResourcePath("/api/v3/projects/[ProjectId]/repository/branches/[BranchName]");
+	setResourcePath("/api/v3/projects/[ProjectId]/repository/branches/delete");
 	setMethod(HttpRequest::Method::Delete);
 }
 

codeup/src/model/GetBranchInfoRequest.cc

@@ -21,7 +21,7 @@ using AlibabaCloud::Codeup::Model::GetBranchInfoRequest;
 GetBranchInfoRequest::GetBranchInfoRequest() :
 	RoaServiceRequest("codeup", "2020-04-14")
 {
-	setResourcePath("/api/v3/projects/[ProjectId]/repository/branches/[BranchName]");
+	setResourcePath("/api/v3/projects/[ProjectId]/repository/branches/detail");
 	setMethod(HttpRequest::Method::Get);
 }
 

codeup/src/model/GetGroupDetailRequest.cc

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/codeup/model/GetGroupDetailRequest.h>
+
+using AlibabaCloud::Codeup::Model::GetGroupDetailRequest;
+
+GetGroupDetailRequest::GetGroupDetailRequest() :
+	RoaServiceRequest("codeup", "2020-04-14")
+{
+	setResourcePath("/api/v3/groups/detail");
+	setMethod(HttpRequest::Method::Get);
+}
+
+GetGroupDetailRequest::~GetGroupDetailRequest()
+{}
+
+std::string GetGroupDetailRequest::getOrganizationId()const
+{
+	return organizationId_;
+}
+
+void GetGroupDetailRequest::setOrganizationId(const std::string& organizationId)
+{
+	organizationId_ = organizationId;
+	setParameter("OrganizationId", organizationId);
+}
+
+std::string GetGroupDetailRequest::getSubUserId()const
+{
+	return subUserId_;
+}
+
+void GetGroupDetailRequest::setSubUserId(const std::string& subUserId)
+{
+	subUserId_ = subUserId;
+	setParameter("SubUserId", subUserId);
+}
+
+long GetGroupDetailRequest::getGroupId()const
+{
+	return groupId_;
+}
+
+void GetGroupDetailRequest::setGroupId(long groupId)
+{
+	groupId_ = groupId;
+	setParameter("GroupId", std::to_string(groupId));
+}
+
+std::string GetGroupDetailRequest::getAccessToken()const
+{
+	return accessToken_;
+}
+
+void GetGroupDetailRequest::setAccessToken(const std::string& accessToken)
+{
+	accessToken_ = accessToken;
+	setParameter("AccessToken", accessToken);
+}
+

codeup/src/model/GetGroupDetailResult.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/codeup/model/GetGroupDetailResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Codeup;
+using namespace AlibabaCloud::Codeup::Model;
+
+GetGroupDetailResult::GetGroupDetailResult() :
+	ServiceResult()
+{}
+
+GetGroupDetailResult::GetGroupDetailResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetGroupDetailResult::~GetGroupDetailResult()
+{}
+
+void GetGroupDetailResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto resultNode = value["Result"];
+	if(!resultNode["Id"].isNull())
+		result_.id = std::stol(resultNode["Id"].asString());
+	if(!resultNode["Name"].isNull())
+		result_.name = resultNode["Name"].asString();
+	if(!resultNode["Path"].isNull())
+		result_.path = resultNode["Path"].asString();
+	if(!resultNode["Description"].isNull())
+		result_.description = resultNode["Description"].asString();
+	if(!resultNode["AvatarUrl"].isNull())
+		result_.avatarUrl = resultNode["AvatarUrl"].asString();
+	if(!resultNode["WebUrl"].isNull())
+		result_.webUrl = resultNode["WebUrl"].asString();
+	if(!resultNode["PathWithNamespace"].isNull())
+		result_.pathWithNamespace = resultNode["PathWithNamespace"].asString();
+	if(!resultNode["NameWithNamespace"].isNull())
+		result_.nameWithNamespace = resultNode["NameWithNamespace"].asString();
+	if(!resultNode["Type"].isNull())
+		result_.type = resultNode["Type"].asString();
+	if(!resultNode["VisibilityLevel"].isNull())
+		result_.visibilityLevel = resultNode["VisibilityLevel"].asString();
+	if(!resultNode["ParentId"].isNull())
+		result_.parentId = std::stol(resultNode["ParentId"].asString());
+	if(!resultNode["OwnerId"].isNull())
+		result_.ownerId = std::stol(resultNode["OwnerId"].asString());
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+
+}
+
+std::string GetGroupDetailResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string GetGroupDetailResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool GetGroupDetailResult::getSuccess()const
+{
+	return success_;
+}
+
+GetGroupDetailResult::Result GetGroupDetailResult::getResult()const
+{
+	return result_;
+}
+

codeup/src/model/ListGroupMemberResult.cc

@@ -63,9 +63,16 @@ void ListGroupMemberResult::parse(const std::string &payload)
 		success_ = value["Success"].asString() == "true";
 	if(!value["ErrorMessage"].isNull())
 		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Total"].isNull())
+		total_ = std::stol(value["Total"].asString());
 
 }
 
+long ListGroupMemberResult::getTotal()const
+{
+	return total_;
+}
+
 std::string ListGroupMemberResult::getErrorCode()const
 {
 	return errorCode_;

codeup/src/model/ListGroupRepositoriesResult.cc

@@ -83,9 +83,16 @@ void ListGroupRepositoriesResult::parse(const std::string &payload)
 		success_ = value["Success"].asString() == "true";
 	if(!value["ErrorMessage"].isNull())
 		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Total"].isNull())
+		total_ = std::stol(value["Total"].asString());
 
 }
 
+long ListGroupRepositoriesResult::getTotal()const
+{
+	return total_;
+}
+
 std::string ListGroupRepositoriesResult::getErrorCode()const
 {
 	return errorCode_;

codeup/src/model/ListGroupsResult.cc

@@ -79,9 +79,16 @@ void ListGroupsResult::parse(const std::string &payload)
 		success_ = value["Success"].asString() == "true";
 	if(!value["ErrorMessage"].isNull())
 		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Total"].isNull())
+		total_ = std::stol(value["Total"].asString());
 
 }
 
+long ListGroupsResult::getTotal()const
+{
+	return total_;
+}
+
 std::string ListGroupsResult::getErrorCode()const
 {
 	return errorCode_;

codeup/src/model/ListRepositoryBranchesRequest.cc

@@ -0,0 +1,107 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/codeup/model/ListRepositoryBranchesRequest.h>
+
+using AlibabaCloud::Codeup::Model::ListRepositoryBranchesRequest;
+
+ListRepositoryBranchesRequest::ListRepositoryBranchesRequest() :
+	RoaServiceRequest("codeup", "2020-04-14")
+{
+	setResourcePath("/api/v3/projects/[ProjectId]/repository/branches");
+	setMethod(HttpRequest::Method::Get);
+}
+
+ListRepositoryBranchesRequest::~ListRepositoryBranchesRequest()
+{}
+
+std::string ListRepositoryBranchesRequest::getOrganizationId()const
+{
+	return organizationId_;
+}
+
+void ListRepositoryBranchesRequest::setOrganizationId(const std::string& organizationId)
+{
+	organizationId_ = organizationId;
+	setParameter("OrganizationId", organizationId);
+}
+
+std::string ListRepositoryBranchesRequest::getSearch()const
+{
+	return search_;
+}
+
+void ListRepositoryBranchesRequest::setSearch(const std::string& search)
+{
+	search_ = search;
+	setParameter("Search", search);
+}
+
+std::string ListRepositoryBranchesRequest::getSubUserId()const
+{
+	return subUserId_;
+}
+
+void ListRepositoryBranchesRequest::setSubUserId(const std::string& subUserId)
+{
+	subUserId_ = subUserId;
+	setParameter("SubUserId", subUserId);
+}
+
+long ListRepositoryBranchesRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListRepositoryBranchesRequest::setPageSize(long pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string ListRepositoryBranchesRequest::getAccessToken()const
+{
+	return accessToken_;
+}
+
+void ListRepositoryBranchesRequest::setAccessToken(const std::string& accessToken)
+{
+	accessToken_ = accessToken;
+	setParameter("AccessToken", accessToken);
+}
+
+long ListRepositoryBranchesRequest::getPage()const
+{
+	return page_;
+}
+
+void ListRepositoryBranchesRequest::setPage(long page)
+{
+	page_ = page;
+	setParameter("Page", std::to_string(page));
+}
+
+long ListRepositoryBranchesRequest::getProjectId()const
+{
+	return projectId_;
+}
+
+void ListRepositoryBranchesRequest::setProjectId(long projectId)
+{
+	projectId_ = projectId;
+	setParameter("ProjectId", std::to_string(projectId));
+}
+

codeup/src/model/ListRepositoryBranchesResult.cc

@@ -0,0 +1,113 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/codeup/model/ListRepositoryBranchesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Codeup;
+using namespace AlibabaCloud::Codeup::Model;
+
+ListRepositoryBranchesResult::ListRepositoryBranchesResult() :
+	ServiceResult()
+{}
+
+ListRepositoryBranchesResult::ListRepositoryBranchesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListRepositoryBranchesResult::~ListRepositoryBranchesResult()
+{}
+
+void ListRepositoryBranchesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResultNode = value["Result"]["ResultItem"];
+	for (auto valueResultResultItem : allResultNode)
+	{
+		ResultItem resultObject;
+		if(!valueResultResultItem["BranchName"].isNull())
+			resultObject.branchName = valueResultResultItem["BranchName"].asString();
+		if(!valueResultResultItem["ProtectedBranch"].isNull())
+			resultObject.protectedBranch = valueResultResultItem["ProtectedBranch"].asString() == "true";
+		auto commitInfoNode = value["CommitInfo"];
+		if(!commitInfoNode["Id"].isNull())
+			resultObject.commitInfo.id = commitInfoNode["Id"].asString();
+		if(!commitInfoNode["ShortId"].isNull())
+			resultObject.commitInfo.shortId = commitInfoNode["ShortId"].asString();
+		if(!commitInfoNode["Title"].isNull())
+			resultObject.commitInfo.title = commitInfoNode["Title"].asString();
+		if(!commitInfoNode["AuthorName"].isNull())
+			resultObject.commitInfo.authorName = commitInfoNode["AuthorName"].asString();
+		if(!commitInfoNode["AuthorEmail"].isNull())
+			resultObject.commitInfo.authorEmail = commitInfoNode["AuthorEmail"].asString();
+		if(!commitInfoNode["CreatedAt"].isNull())
+			resultObject.commitInfo.createdAt = commitInfoNode["CreatedAt"].asString();
+		if(!commitInfoNode["Message"].isNull())
+			resultObject.commitInfo.message = commitInfoNode["Message"].asString();
+		if(!commitInfoNode["AuthorDate"].isNull())
+			resultObject.commitInfo.authorDate = commitInfoNode["AuthorDate"].asString();
+		if(!commitInfoNode["CommittedDate"].isNull())
+			resultObject.commitInfo.committedDate = commitInfoNode["CommittedDate"].asString();
+		if(!commitInfoNode["CommitterEmail"].isNull())
+			resultObject.commitInfo.committerEmail = commitInfoNode["CommitterEmail"].asString();
+		if(!commitInfoNode["CommitterName"].isNull())
+			resultObject.commitInfo.committerName = commitInfoNode["CommitterName"].asString();
+			auto allParentIds = commitInfoNode["ParentIds"]["ParentIds"];
+			for (auto value : allParentIds)
+				resultObject.commitInfo.parentIds.push_back(value.asString());
+		result_.push_back(resultObject);
+	}
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Total"].isNull())
+		total_ = std::stol(value["Total"].asString());
+
+}
+
+long ListRepositoryBranchesResult::getTotal()const
+{
+	return total_;
+}
+
+std::string ListRepositoryBranchesResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListRepositoryBranchesResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool ListRepositoryBranchesResult::getSuccess()const
+{
+	return success_;
+}
+
+std::vector<ListRepositoryBranchesResult::ResultItem> ListRepositoryBranchesResult::getResult()const
+{
+	return result_;
+}
+

codeup/src/model/ListRepositoryMemberResult.cc

@@ -63,9 +63,16 @@ void ListRepositoryMemberResult::parse(const std::string &payload)
 		success_ = value["Success"].asString() == "true";
 	if(!value["ErrorMessage"].isNull())
 		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["Total"].isNull())
+		total_ = std::stol(value["Total"].asString());
 
 }
 
+long ListRepositoryMemberResult::getTotal()const
+{
+	return total_;
+}
+
 std::string ListRepositoryMemberResult::getErrorCode()const
 {
 	return errorCode_;

codeup/src/model/MergeMergeRequestResult.cc

@@ -112,18 +112,18 @@ void MergeMergeRequestResult::parse(const std::string &payload)
 			satisfiedCheckResultsItemObject.checkName = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItem["CheckName"].asString();
 		if(!approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItem["CheckType"].isNull())
 			satisfiedCheckResultsItemObject.checkType = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItem["CheckType"].asString();
-		auto allExtraUsersNode = allSatisfiedCheckResultsNode["ExtraUsers"]["ExtraUsersItem"];
-		for (auto allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem : allExtraUsersNode)
+		auto allExtraUsersNode = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItem["ExtraUsers"]["ExtraUsersItem"];
+		for (auto approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem : allExtraUsersNode)
 		{
 			Result::ApproveCheckResult::SatisfiedCheckResultsItem::ExtraUsersItem extraUsersObject;
-			if(!allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Id"].isNull())
-				extraUsersObject.id = std::stol(allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Id"].asString());
-			if(!allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["ExternUserId"].isNull())
-				extraUsersObject.externUserId = allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["ExternUserId"].asString();
-			if(!allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["AvatarUrl"].isNull())
-				extraUsersObject.avatarUrl = allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["AvatarUrl"].asString();
-			if(!allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Name"].isNull())
-				extraUsersObject.name = allSatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Name"].asString();
+			if(!approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["Id"].isNull())
+				extraUsersObject.id = std::stol(approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["Id"].asString());
+			if(!approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["ExternUserId"].isNull())
+				extraUsersObject.externUserId = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["ExternUserId"].asString();
+			if(!approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["AvatarUrl"].isNull())
+				extraUsersObject.avatarUrl = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["AvatarUrl"].asString();
+			if(!approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["Name"].isNull())
+				extraUsersObject.name = approveCheckResultNodeSatisfiedCheckResultsSatisfiedCheckResultsItemExtraUsersExtraUsersItem["Name"].asString();
 			satisfiedCheckResultsItemObject.extraUsers.push_back(extraUsersObject);
 		}
 		auto allSatisfiedItems = value["SatisfiedItems"]["SatisfiedItems"];
@@ -144,18 +144,18 @@ void MergeMergeRequestResult::parse(const std::string &payload)
 			unsatisfiedCheckResultsItemObject.checkName = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItem["CheckName"].asString();
 		if(!approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItem["CheckType"].isNull())
 			unsatisfiedCheckResultsItemObject.checkType = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItem["CheckType"].asString();
-		auto allExtraUsers3Node = allUnsatisfiedCheckResultsNode["ExtraUsers"]["ExtraUsersItem"];
-		for (auto allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem : allExtraUsers3Node)
+		auto allExtraUsers3Node = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItem["ExtraUsers"]["ExtraUsersItem"];
+		for (auto approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem : allExtraUsers3Node)
 		{
 			Result::ApproveCheckResult::UnsatisfiedCheckResultsItem::ExtraUsersItem4 extraUsers3Object;
-			if(!allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Id"].isNull())
-				extraUsers3Object.id = std::stol(allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Id"].asString());
-			if(!allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["ExternUserId"].isNull())
-				extraUsers3Object.externUserId = allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["ExternUserId"].asString();
-			if(!allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["AvatarUrl"].isNull())
-				extraUsers3Object.avatarUrl = allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["AvatarUrl"].asString();
-			if(!allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Name"].isNull())
-				extraUsers3Object.name = allUnsatisfiedCheckResultsNodeExtraUsersExtraUsersItem["Name"].asString();
+			if(!approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["Id"].isNull())
+				extraUsers3Object.id = std::stol(approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["Id"].asString());
+			if(!approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["ExternUserId"].isNull())
+				extraUsers3Object.externUserId = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["ExternUserId"].asString();
+			if(!approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["AvatarUrl"].isNull())
+				extraUsers3Object.avatarUrl = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["AvatarUrl"].asString();
+			if(!approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["Name"].isNull())
+				extraUsers3Object.name = approveCheckResultNodeUnsatisfiedCheckResultsUnsatisfiedCheckResultsItemExtraUsersExtraUsersItem["Name"].asString();
 			unsatisfiedCheckResultsItemObject.extraUsers3.push_back(extraUsers3Object);
 		}
 		auto allSatisfiedItems1 = value["SatisfiedItems"]["SatisfiedItems"];

config/include/alibabacloud/config/model/DescribeConfigRuleResult.h

@@ -103,6 +103,7 @@ namespace AlibabaCloud
 					ConfigRuleEvaluationStatus configRuleEvaluationStatus;
 					Source source;
 					std::string configRuleState;
+					std::string maximumExecutionFrequency;
 					std::string configRuleId;
 					Scope scope;
 					std::string configRuleArn;

config/include/alibabacloud/config/model/GetResourceConfigurationTimelineResult.h

@@ -37,16 +37,17 @@ namespace AlibabaCloud
 					struct ConfigurationListItem
 					{
 						long accountId;
+						std::string resourceName;
+						std::string availabilityZone;
+						std::string resourceType;
+						std::string resourceEventType;
+						std::string resourceCreateTime;
+						std::string relationshipDiff;
 						std::string captureTime;
 						std::string configurationDiff;
 						std::string resourceId;
-						std::string resourceName;
 						std::string relationship;
-						std::string availabilityZone;
 						std::string region;
-						std::string resourceType;
-						std::string resourceCreateTime;
-						std::string relationshipDiff;
 						std::string tags;
 					};
 					long totalCount;

config/include/alibabacloud/config/model/ListConfigRulesRequest.h

@@ -41,14 +41,16 @@ namespace AlibabaCloud
 				void setMessageType(const std::string& messageType);
 				std::string getConfigRuleState()const;
 				void setConfigRuleState(const std::string& configRuleState);
-				int getRiskLevel()const;
-				void setRiskLevel(int riskLevel);
 				int getPageNumber()const;
 				void setPageNumber(int pageNumber);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
 				std::string getComplianceType()const;
 				void setComplianceType(const std::string& complianceType);
+				std::string getConfigRuleSceneId()const;
+				void setConfigRuleSceneId(const std::string& configRuleSceneId);
+				int getRiskLevel()const;
+				void setRiskLevel(int riskLevel);
 				long getMemberId()const;
 				void setMemberId(long memberId);
 
@@ -56,10 +58,11 @@ namespace AlibabaCloud
 				bool multiAccount_;
 				std::string messageType_;
 				std::string configRuleState_;
-				int riskLevel_;
 				int pageNumber_;
 				int pageSize_;
 				std::string complianceType_;
+				std::string configRuleSceneId_;
+				int riskLevel_;
 				long memberId_;
 
 			};

config/src/ConfigClient.cc

@@ -31,21 +31,21 @@ ConfigClient::ConfigClient(const Credentials &credentials, const ClientConfigura
 	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, "config");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "Config");
 }
 
 ConfigClient::ConfigClient(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, "config");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "Config");
 }
 
 ConfigClient::ConfigClient(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, "config");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "Config");
 }
 
 ConfigClient::~ConfigClient()

config/src/model/DescribeConfigRuleResult.cc

@@ -58,6 +58,8 @@ void DescribeConfigRuleResult::parse(const std::string &payload)
 		configRule_.modifiedTimestamp = std::stol(configRuleNode["ModifiedTimestamp"].asString());
 	if(!configRuleNode["RiskLevel"].isNull())
 		configRule_.riskLevel = std::stoi(configRuleNode["RiskLevel"].asString());
+	if(!configRuleNode["MaximumExecutionFrequency"].isNull())
+		configRule_.maximumExecutionFrequency = configRuleNode["MaximumExecutionFrequency"].asString();
 	auto createByNode = configRuleNode["CreateBy"];
 	if(!createByNode["CreatorType"].isNull())
 		configRule_.createBy.creatorType = createByNode["CreatorType"].asString();

config/src/model/GetResourceConfigurationTimelineResult.cc

@@ -74,6 +74,8 @@ void GetResourceConfigurationTimelineResult::parse(const std::string &payload)
 			configurationListItemObject.resourceType = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ResourceType"].asString();
 		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["Tags"].isNull())
 			configurationListItemObject.tags = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["Tags"].asString();
+		if(!resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ResourceEventType"].isNull())
+			configurationListItemObject.resourceEventType = resourceConfigurationTimelineNodeConfigurationListConfigurationListItem["ResourceEventType"].asString();
 		resourceConfigurationTimeline_.configurationList.push_back(configurationListItemObject);
 	}
 

config/src/model/ListConfigRulesRequest.cc

@@ -60,17 +60,6 @@ void ListConfigRulesRequest::setConfigRuleState(const std::string& configRuleSta
 	setParameter("ConfigRuleState", configRuleState);
 }
 
-int ListConfigRulesRequest::getRiskLevel()const
-{
-	return riskLevel_;
-}
-
-void ListConfigRulesRequest::setRiskLevel(int riskLevel)
-{
-	riskLevel_ = riskLevel;
-	setParameter("RiskLevel", std::to_string(riskLevel));
-}
-
 int ListConfigRulesRequest::getPageNumber()const
 {
 	return pageNumber_;
@@ -104,6 +93,28 @@ void ListConfigRulesRequest::setComplianceType(const std::string& complianceType
 	setParameter("ComplianceType", complianceType);
 }
 
+std::string ListConfigRulesRequest::getConfigRuleSceneId()const
+{
+	return configRuleSceneId_;
+}
+
+void ListConfigRulesRequest::setConfigRuleSceneId(const std::string& configRuleSceneId)
+{
+	configRuleSceneId_ = configRuleSceneId;
+	setParameter("ConfigRuleSceneId", configRuleSceneId);
+}
+
+int ListConfigRulesRequest::getRiskLevel()const
+{
+	return riskLevel_;
+}
+
+void ListConfigRulesRequest::setRiskLevel(int riskLevel)
+{
+	riskLevel_ = riskLevel;
+	setParameter("RiskLevel", std::to_string(riskLevel));
+}
+
 long ListConfigRulesRequest::getMemberId()const
 {
 	return memberId_;

dds/CMakeLists.txt

@@ -37,6 +37,8 @@ set(dds_public_header_model
 	include/alibabacloud/dds/model/CreateNodeResult.h
 	include/alibabacloud/dds/model/CreateRecommendationTaskRequest.h
 	include/alibabacloud/dds/model/CreateRecommendationTaskResult.h
+	include/alibabacloud/dds/model/CreateServerlessDBInstanceRequest.h
+	include/alibabacloud/dds/model/CreateServerlessDBInstanceResult.h
 	include/alibabacloud/dds/model/CreateShardingDBInstanceRequest.h
 	include/alibabacloud/dds/model/CreateShardingDBInstanceResult.h
 	include/alibabacloud/dds/model/DeleteDBInstanceRequest.h
@@ -83,6 +85,8 @@ set(dds_public_header_model
 	include/alibabacloud/dds/model/DescribeDBInstanceTDEInfoResult.h
 	include/alibabacloud/dds/model/DescribeDBInstancesRequest.h
 	include/alibabacloud/dds/model/DescribeDBInstancesResult.h
+	include/alibabacloud/dds/model/DescribeDedicatedClusterInstanceListRequest.h
+	include/alibabacloud/dds/model/DescribeDedicatedClusterInstanceListResult.h
 	include/alibabacloud/dds/model/DescribeErrorLogRecordsRequest.h
 	include/alibabacloud/dds/model/DescribeErrorLogRecordsResult.h
 	include/alibabacloud/dds/model/DescribeIndexRecommendationRequest.h
@@ -214,6 +218,8 @@ set(dds_src
 	src/model/CreateNodeResult.cc
 	src/model/CreateRecommendationTaskRequest.cc
 	src/model/CreateRecommendationTaskResult.cc
+	src/model/CreateServerlessDBInstanceRequest.cc
+	src/model/CreateServerlessDBInstanceResult.cc
 	src/model/CreateShardingDBInstanceRequest.cc
 	src/model/CreateShardingDBInstanceResult.cc
 	src/model/DeleteDBInstanceRequest.cc
@@ -260,6 +266,8 @@ set(dds_src
 	src/model/DescribeDBInstanceTDEInfoResult.cc
 	src/model/DescribeDBInstancesRequest.cc
 	src/model/DescribeDBInstancesResult.cc
+	src/model/DescribeDedicatedClusterInstanceListRequest.cc
+	src/model/DescribeDedicatedClusterInstanceListResult.cc
 	src/model/DescribeErrorLogRecordsRequest.cc
 	src/model/DescribeErrorLogRecordsResult.cc
 	src/model/DescribeIndexRecommendationRequest.cc

dds/include/alibabacloud/dds/DdsClient.h

@@ -38,6 +38,8 @@
 #include "model/CreateNodeResult.h"
 #include "model/CreateRecommendationTaskRequest.h"
 #include "model/CreateRecommendationTaskResult.h"
+#include "model/CreateServerlessDBInstanceRequest.h"
+#include "model/CreateServerlessDBInstanceResult.h"
 #include "model/CreateShardingDBInstanceRequest.h"
 #include "model/CreateShardingDBInstanceResult.h"
 #include "model/DeleteDBInstanceRequest.h"
@@ -84,6 +86,8 @@
 #include "model/DescribeDBInstanceTDEInfoResult.h"
 #include "model/DescribeDBInstancesRequest.h"
 #include "model/DescribeDBInstancesResult.h"
+#include "model/DescribeDedicatedClusterInstanceListRequest.h"
+#include "model/DescribeDedicatedClusterInstanceListResult.h"
 #include "model/DescribeErrorLogRecordsRequest.h"
 #include "model/DescribeErrorLogRecordsResult.h"
 #include "model/DescribeIndexRecommendationRequest.h"
@@ -229,6 +233,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateRecommendationTaskResult> CreateRecommendationTaskOutcome;
 			typedef std::future<CreateRecommendationTaskOutcome> CreateRecommendationTaskOutcomeCallable;
 			typedef std::function<void(const DdsClient*, const Model::CreateRecommendationTaskRequest&, const CreateRecommendationTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRecommendationTaskAsyncHandler;
+			typedef Outcome<Error, Model::CreateServerlessDBInstanceResult> CreateServerlessDBInstanceOutcome;
+			typedef std::future<CreateServerlessDBInstanceOutcome> CreateServerlessDBInstanceOutcomeCallable;
+			typedef std::function<void(const DdsClient*, const Model::CreateServerlessDBInstanceRequest&, const CreateServerlessDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateServerlessDBInstanceAsyncHandler;
 			typedef Outcome<Error, Model::CreateShardingDBInstanceResult> CreateShardingDBInstanceOutcome;
 			typedef std::future<CreateShardingDBInstanceOutcome> CreateShardingDBInstanceOutcomeCallable;
 			typedef std::function<void(const DdsClient*, const Model::CreateShardingDBInstanceRequest&, const CreateShardingDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateShardingDBInstanceAsyncHandler;
@@ -298,6 +305,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDBInstancesResult> DescribeDBInstancesOutcome;
 			typedef std::future<DescribeDBInstancesOutcome> DescribeDBInstancesOutcomeCallable;
 			typedef std::function<void(const DdsClient*, const Model::DescribeDBInstancesRequest&, const DescribeDBInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstancesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDedicatedClusterInstanceListResult> DescribeDedicatedClusterInstanceListOutcome;
+			typedef std::future<DescribeDedicatedClusterInstanceListOutcome> DescribeDedicatedClusterInstanceListOutcomeCallable;
+			typedef std::function<void(const DdsClient*, const Model::DescribeDedicatedClusterInstanceListRequest&, const DescribeDedicatedClusterInstanceListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDedicatedClusterInstanceListAsyncHandler;
 			typedef Outcome<Error, Model::DescribeErrorLogRecordsResult> DescribeErrorLogRecordsOutcome;
 			typedef std::future<DescribeErrorLogRecordsOutcome> DescribeErrorLogRecordsOutcomeCallable;
 			typedef std::function<void(const DdsClient*, const Model::DescribeErrorLogRecordsRequest&, const DescribeErrorLogRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeErrorLogRecordsAsyncHandler;
@@ -495,6 +505,9 @@ namespace AlibabaCloud
 			CreateRecommendationTaskOutcome createRecommendationTask(const Model::CreateRecommendationTaskRequest &request)const;
 			void createRecommendationTaskAsync(const Model::CreateRecommendationTaskRequest& request, const CreateRecommendationTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateRecommendationTaskOutcomeCallable createRecommendationTaskCallable(const Model::CreateRecommendationTaskRequest& request) const;
+			CreateServerlessDBInstanceOutcome createServerlessDBInstance(const Model::CreateServerlessDBInstanceRequest &request)const;
+			void createServerlessDBInstanceAsync(const Model::CreateServerlessDBInstanceRequest& request, const CreateServerlessDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateServerlessDBInstanceOutcomeCallable createServerlessDBInstanceCallable(const Model::CreateServerlessDBInstanceRequest& request) const;
 			CreateShardingDBInstanceOutcome createShardingDBInstance(const Model::CreateShardingDBInstanceRequest &request)const;
 			void createShardingDBInstanceAsync(const Model::CreateShardingDBInstanceRequest& request, const CreateShardingDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateShardingDBInstanceOutcomeCallable createShardingDBInstanceCallable(const Model::CreateShardingDBInstanceRequest& request) const;
@@ -564,6 +577,9 @@ namespace AlibabaCloud
 			DescribeDBInstancesOutcome describeDBInstances(const Model::DescribeDBInstancesRequest &request)const;
 			void describeDBInstancesAsync(const Model::DescribeDBInstancesRequest& request, const DescribeDBInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDBInstancesOutcomeCallable describeDBInstancesCallable(const Model::DescribeDBInstancesRequest& request) const;
+			DescribeDedicatedClusterInstanceListOutcome describeDedicatedClusterInstanceList(const Model::DescribeDedicatedClusterInstanceListRequest &request)const;
+			void describeDedicatedClusterInstanceListAsync(const Model::DescribeDedicatedClusterInstanceListRequest& request, const DescribeDedicatedClusterInstanceListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDedicatedClusterInstanceListOutcomeCallable describeDedicatedClusterInstanceListCallable(const Model::DescribeDedicatedClusterInstanceListRequest& request) const;
 			DescribeErrorLogRecordsOutcome describeErrorLogRecords(const Model::DescribeErrorLogRecordsRequest &request)const;
 			void describeErrorLogRecordsAsync(const Model::DescribeErrorLogRecordsRequest& request, const DescribeErrorLogRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeErrorLogRecordsOutcomeCallable describeErrorLogRecordsCallable(const Model::DescribeErrorLogRecordsRequest& request) const;

dds/include/alibabacloud/dds/model/CreateDBInstanceRequest.h

@@ -91,6 +91,8 @@ namespace AlibabaCloud
 				void setSrcDBInstanceId(const std::string& srcDBInstanceId);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
 				std::string getAccountPassword()const;
 				void setAccountPassword(const std::string& accountPassword);
 				std::string getVpcId()const;
@@ -127,6 +129,7 @@ namespace AlibabaCloud
 				std::string resourceOwnerAccount_;
 				std::string srcDBInstanceId_;
 				std::string ownerAccount_;
+				std::string clusterId_;
 				std::string accountPassword_;
 				std::string vpcId_;
 				std::string chargeType_;

dds/include/alibabacloud/dds/model/CreateServerlessDBInstanceRequest.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDS_MODEL_CREATESERVERLESSDBINSTANCEREQUEST_H_
+#define ALIBABACLOUD_DDS_MODEL_CREATESERVERLESSDBINSTANCEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dds/DdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDS_EXPORT CreateServerlessDBInstanceRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateServerlessDBInstanceRequest();
+				~CreateServerlessDBInstanceRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				int getDBInstanceStorage()const;
+				void setDBInstanceStorage(int dBInstanceStorage);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				std::string getPeriodPriceType()const;
+				void setPeriodPriceType(const std::string& periodPriceType);
+				std::string getEngineVersion()const;
+				void setEngineVersion(const std::string& engineVersion);
+				std::string getNetworkType()const;
+				void setNetworkType(const std::string& networkType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getStorageEngine()const;
+				void setStorageEngine(const std::string& storageEngine);
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getEngine()const;
+				void setEngine(const std::string& engine);
+				std::string getDBInstanceDescription()const;
+				void setDBInstanceDescription(const std::string& dBInstanceDescription);
+				int getPeriod()const;
+				void setPeriod(int period);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getSecurityIPList()const;
+				void setSecurityIPList(const std::string& securityIPList);
+				std::string getVSwitchId()const;
+				void setVSwitchId(const std::string& vSwitchId);
+				std::string getAccountPassword()const;
+				void setAccountPassword(const std::string& accountPassword);
+				std::string getAutoRenew()const;
+				void setAutoRenew(const std::string& autoRenew);
+				std::string getVpcId()const;
+				void setVpcId(const std::string& vpcId);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+				std::string getChargeType()const;
+				void setChargeType(const std::string& chargeType);
+
+            private:
+				long resourceOwnerId_;
+				int dBInstanceStorage_;
+				std::string clientToken_;
+				std::string periodPriceType_;
+				std::string engineVersion_;
+				std::string networkType_;
+				std::string accessKeyId_;
+				std::string storageEngine_;
+				std::string resourceGroupId_;
+				std::string securityToken_;
+				std::string regionId_;
+				std::string engine_;
+				std::string dBInstanceDescription_;
+				int period_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string securityIPList_;
+				std::string vSwitchId_;
+				std::string accountPassword_;
+				std::string autoRenew_;
+				std::string vpcId_;
+				std::string zoneId_;
+				std::string chargeType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDS_MODEL_CREATESERVERLESSDBINSTANCEREQUEST_H_

dds/include/alibabacloud/dds/model/CreateServerlessDBInstanceResult.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_DDS_MODEL_CREATESERVERLESSDBINSTANCERESULT_H_
+#define ALIBABACLOUD_DDS_MODEL_CREATESERVERLESSDBINSTANCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dds/DdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDS_EXPORT CreateServerlessDBInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				CreateServerlessDBInstanceResult();
+				explicit CreateServerlessDBInstanceResult(const std::string &payload);
+				~CreateServerlessDBInstanceResult();
+				std::string getDBInstanceId()const;
+				std::string getOrderId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string dBInstanceId_;
+				std::string orderId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDS_MODEL_CREATESERVERLESSDBINSTANCERESULT_H_

dds/include/alibabacloud/dds/model/DescribeDBInstancesResult.h

@@ -72,6 +72,7 @@ namespace AlibabaCloud
 					std::string creationTime;
 					std::string regionId;
 					std::string expireTime;
+					std::string kindCode;
 					std::vector<DBInstance::Tag> tags;
 					std::string dBInstanceDescription;
 					std::string engine;

dds/include/alibabacloud/dds/model/DescribeDedicatedClusterInstanceListRequest.h

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DDS_MODEL_DESCRIBEDEDICATEDCLUSTERINSTANCELISTREQUEST_H_
+#define ALIBABACLOUD_DDS_MODEL_DESCRIBEDEDICATEDCLUSTERINSTANCELISTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dds/DdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDS_EXPORT DescribeDedicatedClusterInstanceListRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDedicatedClusterInstanceListRequest();
+				~DescribeDedicatedClusterInstanceListRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getEngineVersion()const;
+				void setEngineVersion(const std::string& engineVersion);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getEngine()const;
+				void setEngine(const std::string& engine);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getInstanceStatus()const;
+				void setInstanceStatus(int instanceStatus);
+				std::string getDedicatedHostName()const;
+				void setDedicatedHostName(const std::string& dedicatedHostName);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getInstanceNetType()const;
+				void setInstanceNetType(const std::string& instanceNetType);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string engineVersion_;
+				int pageNumber_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string engine_;
+				int pageSize_;
+				int instanceStatus_;
+				std::string dedicatedHostName_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				std::string instanceNetType_;
+				std::string clusterId_;
+				long ownerId_;
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDS_MODEL_DESCRIBEDEDICATEDCLUSTERINSTANCELISTREQUEST_H_

dds/include/alibabacloud/dds/model/DescribeDedicatedClusterInstanceListResult.h

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DDS_MODEL_DESCRIBEDEDICATEDCLUSTERINSTANCELISTRESULT_H_
+#define ALIBABACLOUD_DDS_MODEL_DESCRIBEDEDICATEDCLUSTERINSTANCELISTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dds/DdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DDS_EXPORT DescribeDedicatedClusterInstanceListResult : public ServiceResult
+			{
+			public:
+				struct DbInstance
+				{
+					struct InstanceNodes
+					{
+						std::string role;
+						std::string zoneId;
+						std::string dedicatedHostName;
+						std::string nodeType;
+						int port;
+						int nodeId;
+						std::string insName;
+						std::string nodeIp;
+					};
+					std::string engineVersion;
+					std::string storageType;
+					std::string zoneId;
+					std::string clusterId;
+					std::string instanceId;
+					std::string createTime;
+					std::string instanceClass;
+					int characterType;
+					std::string vswitchId;
+					std::string instanceName;
+					std::string connectionDomain;
+					std::string maintainEndTime;
+					std::string vpcId;
+					std::string instanceStatus;
+					std::vector<DbInstance::InstanceNodes> instanceNodeList;
+					std::string customId;
+					std::string region;
+					std::string clusterName;
+					std::string regionId;
+					std::string maintainStartTime;
+					std::string engine;
+				};
+
+
+				DescribeDedicatedClusterInstanceListResult();
+				explicit DescribeDedicatedClusterInstanceListResult(const std::string &payload);
+				~DescribeDedicatedClusterInstanceListResult();
+				std::vector<DbInstance> getInstances()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DbInstance> instances_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DDS_MODEL_DESCRIBEDEDICATEDCLUSTERINSTANCELISTRESULT_H_

dds/include/alibabacloud/dds/model/DescribeRegionsResult.h

@@ -37,6 +37,7 @@ namespace AlibabaCloud
 					struct Zone
 					{
 						bool vpcEnabled;
+						std::string zoneName;
 						std::string zoneId;
 					};
 					std::string regionId;

dds/src/DdsClient.cc

@@ -339,6 +339,42 @@ DdsClient::CreateRecommendationTaskOutcomeCallable DdsClient::createRecommendati
 	return task->get_future();
 }
 
+DdsClient::CreateServerlessDBInstanceOutcome DdsClient::createServerlessDBInstance(const CreateServerlessDBInstanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateServerlessDBInstanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateServerlessDBInstanceOutcome(CreateServerlessDBInstanceResult(outcome.result()));
+	else
+		return CreateServerlessDBInstanceOutcome(outcome.error());
+}
+
+void DdsClient::createServerlessDBInstanceAsync(const CreateServerlessDBInstanceRequest& request, const CreateServerlessDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createServerlessDBInstance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DdsClient::CreateServerlessDBInstanceOutcomeCallable DdsClient::createServerlessDBInstanceCallable(const CreateServerlessDBInstanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateServerlessDBInstanceOutcome()>>(
+			[this, request]()
+			{
+			return this->createServerlessDBInstance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DdsClient::CreateShardingDBInstanceOutcome DdsClient::createShardingDBInstance(const CreateShardingDBInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1167,6 +1203,42 @@ DdsClient::DescribeDBInstancesOutcomeCallable DdsClient::describeDBInstancesCall
 	return task->get_future();
 }
 
+DdsClient::DescribeDedicatedClusterInstanceListOutcome DdsClient::describeDedicatedClusterInstanceList(const DescribeDedicatedClusterInstanceListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDedicatedClusterInstanceListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDedicatedClusterInstanceListOutcome(DescribeDedicatedClusterInstanceListResult(outcome.result()));
+	else
+		return DescribeDedicatedClusterInstanceListOutcome(outcome.error());
+}
+
+void DdsClient::describeDedicatedClusterInstanceListAsync(const DescribeDedicatedClusterInstanceListRequest& request, const DescribeDedicatedClusterInstanceListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDedicatedClusterInstanceList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DdsClient::DescribeDedicatedClusterInstanceListOutcomeCallable DdsClient::describeDedicatedClusterInstanceListCallable(const DescribeDedicatedClusterInstanceListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDedicatedClusterInstanceListOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDedicatedClusterInstanceList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DdsClient::DescribeErrorLogRecordsOutcome DdsClient::describeErrorLogRecords(const DescribeErrorLogRecordsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dds/src/model/CreateDBInstanceRequest.cc

@@ -335,6 +335,17 @@ void CreateDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+std::string CreateDBInstanceRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void CreateDBInstanceRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
 std::string CreateDBInstanceRequest::getAccountPassword()const
 {
 	return accountPassword_;

dds/src/model/CreateServerlessDBInstanceRequest.cc

@@ -0,0 +1,293 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/dds/model/CreateServerlessDBInstanceRequest.h>
+
+using AlibabaCloud::Dds::Model::CreateServerlessDBInstanceRequest;
+
+CreateServerlessDBInstanceRequest::CreateServerlessDBInstanceRequest() :
+	RpcServiceRequest("dds", "2015-12-01", "CreateServerlessDBInstance")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CreateServerlessDBInstanceRequest::~CreateServerlessDBInstanceRequest()
+{}
+
+long CreateServerlessDBInstanceRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CreateServerlessDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+int CreateServerlessDBInstanceRequest::getDBInstanceStorage()const
+{
+	return dBInstanceStorage_;
+}
+
+void CreateServerlessDBInstanceRequest::setDBInstanceStorage(int dBInstanceStorage)
+{
+	dBInstanceStorage_ = dBInstanceStorage;
+	setParameter("DBInstanceStorage", std::to_string(dBInstanceStorage));
+}
+
+std::string CreateServerlessDBInstanceRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void CreateServerlessDBInstanceRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+std::string CreateServerlessDBInstanceRequest::getPeriodPriceType()const
+{
+	return periodPriceType_;
+}
+
+void CreateServerlessDBInstanceRequest::setPeriodPriceType(const std::string& periodPriceType)
+{
+	periodPriceType_ = periodPriceType;
+	setParameter("PeriodPriceType", periodPriceType);
+}
+
+std::string CreateServerlessDBInstanceRequest::getEngineVersion()const
+{
+	return engineVersion_;
+}
+
+void CreateServerlessDBInstanceRequest::setEngineVersion(const std::string& engineVersion)
+{
+	engineVersion_ = engineVersion;
+	setParameter("EngineVersion", engineVersion);
+}
+
+std::string CreateServerlessDBInstanceRequest::getNetworkType()const
+{
+	return networkType_;
+}
+
+void CreateServerlessDBInstanceRequest::setNetworkType(const std::string& networkType)
+{
+	networkType_ = networkType;
+	setParameter("NetworkType", networkType);
+}
+
+std::string CreateServerlessDBInstanceRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateServerlessDBInstanceRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getStorageEngine()const
+{
+	return storageEngine_;
+}
+
+void CreateServerlessDBInstanceRequest::setStorageEngine(const std::string& storageEngine)
+{
+	storageEngine_ = storageEngine;
+	setParameter("StorageEngine", storageEngine);
+}
+
+std::string CreateServerlessDBInstanceRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void CreateServerlessDBInstanceRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void CreateServerlessDBInstanceRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string CreateServerlessDBInstanceRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateServerlessDBInstanceRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getEngine()const
+{
+	return engine_;
+}
+
+void CreateServerlessDBInstanceRequest::setEngine(const std::string& engine)
+{
+	engine_ = engine;
+	setParameter("Engine", engine);
+}
+
+std::string CreateServerlessDBInstanceRequest::getDBInstanceDescription()const
+{
+	return dBInstanceDescription_;
+}
+
+void CreateServerlessDBInstanceRequest::setDBInstanceDescription(const std::string& dBInstanceDescription)
+{
+	dBInstanceDescription_ = dBInstanceDescription;
+	setParameter("DBInstanceDescription", dBInstanceDescription);
+}
+
+int CreateServerlessDBInstanceRequest::getPeriod()const
+{
+	return period_;
+}
+
+void CreateServerlessDBInstanceRequest::setPeriod(int period)
+{
+	period_ = period;
+	setParameter("Period", std::to_string(period));
+}
+
+std::string CreateServerlessDBInstanceRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CreateServerlessDBInstanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string CreateServerlessDBInstanceRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void CreateServerlessDBInstanceRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long CreateServerlessDBInstanceRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CreateServerlessDBInstanceRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CreateServerlessDBInstanceRequest::getSecurityIPList()const
+{
+	return securityIPList_;
+}
+
+void CreateServerlessDBInstanceRequest::setSecurityIPList(const std::string& securityIPList)
+{
+	securityIPList_ = securityIPList;
+	setParameter("SecurityIPList", securityIPList);
+}
+
+std::string CreateServerlessDBInstanceRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void CreateServerlessDBInstanceRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getAccountPassword()const
+{
+	return accountPassword_;
+}
+
+void CreateServerlessDBInstanceRequest::setAccountPassword(const std::string& accountPassword)
+{
+	accountPassword_ = accountPassword;
+	setParameter("AccountPassword", accountPassword);
+}
+
+std::string CreateServerlessDBInstanceRequest::getAutoRenew()const
+{
+	return autoRenew_;
+}
+
+void CreateServerlessDBInstanceRequest::setAutoRenew(const std::string& autoRenew)
+{
+	autoRenew_ = autoRenew;
+	setParameter("AutoRenew", autoRenew);
+}
+
+std::string CreateServerlessDBInstanceRequest::getVpcId()const
+{
+	return vpcId_;
+}
+
+void CreateServerlessDBInstanceRequest::setVpcId(const std::string& vpcId)
+{
+	vpcId_ = vpcId;
+	setParameter("VpcId", vpcId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void CreateServerlessDBInstanceRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+
+std::string CreateServerlessDBInstanceRequest::getChargeType()const
+{
+	return chargeType_;
+}
+
+void CreateServerlessDBInstanceRequest::setChargeType(const std::string& chargeType)
+{
+	chargeType_ = chargeType;
+	setParameter("ChargeType", chargeType);
+}
+

dds/src/model/CreateServerlessDBInstanceResult.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/dds/model/CreateServerlessDBInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dds;
+using namespace AlibabaCloud::Dds::Model;
+
+CreateServerlessDBInstanceResult::CreateServerlessDBInstanceResult() :
+	ServiceResult()
+{}
+
+CreateServerlessDBInstanceResult::CreateServerlessDBInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateServerlessDBInstanceResult::~CreateServerlessDBInstanceResult()
+{}
+
+void CreateServerlessDBInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["OrderId"].isNull())
+		orderId_ = value["OrderId"].asString();
+	if(!value["DBInstanceId"].isNull())
+		dBInstanceId_ = value["DBInstanceId"].asString();
+
+}
+
+std::string CreateServerlessDBInstanceResult::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+std::string CreateServerlessDBInstanceResult::getOrderId()const
+{
+	return orderId_;
+}
+

dds/src/model/DescribeDBInstancesResult.cc

@@ -61,6 +61,8 @@ void DescribeDBInstancesResult::parse(const std::string &payload)
 			dBInstancesObject.dBInstanceClass = valueDBInstancesDBInstance["DBInstanceClass"].asString();
 		if(!valueDBInstancesDBInstance["DBInstanceStorage"].isNull())
 			dBInstancesObject.dBInstanceStorage = std::stoi(valueDBInstancesDBInstance["DBInstanceStorage"].asString());
+		if(!valueDBInstancesDBInstance["KindCode"].isNull())
+			dBInstancesObject.kindCode = valueDBInstancesDBInstance["KindCode"].asString();
 		if(!valueDBInstancesDBInstance["DBInstanceStatus"].isNull())
 			dBInstancesObject.dBInstanceStatus = valueDBInstancesDBInstance["DBInstanceStatus"].asString();
 		if(!valueDBInstancesDBInstance["LockMode"].isNull())

dds/src/model/DescribeDedicatedClusterInstanceListRequest.cc

@@ -0,0 +1,194 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/dds/model/DescribeDedicatedClusterInstanceListRequest.h>
+
+using AlibabaCloud::Dds::Model::DescribeDedicatedClusterInstanceListRequest;
+
+DescribeDedicatedClusterInstanceListRequest::DescribeDedicatedClusterInstanceListRequest() :
+	RpcServiceRequest("dds", "2015-12-01", "DescribeDedicatedClusterInstanceList")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDedicatedClusterInstanceListRequest::~DescribeDedicatedClusterInstanceListRequest()
+{}
+
+long DescribeDedicatedClusterInstanceListRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getEngineVersion()const
+{
+	return engineVersion_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setEngineVersion(const std::string& engineVersion)
+{
+	engineVersion_ = engineVersion;
+	setParameter("EngineVersion", engineVersion);
+}
+
+int DescribeDedicatedClusterInstanceListRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getEngine()const
+{
+	return engine_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setEngine(const std::string& engine)
+{
+	engine_ = engine;
+	setParameter("Engine", engine);
+}
+
+int DescribeDedicatedClusterInstanceListRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+int DescribeDedicatedClusterInstanceListRequest::getInstanceStatus()const
+{
+	return instanceStatus_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setInstanceStatus(int instanceStatus)
+{
+	instanceStatus_ = instanceStatus;
+	setParameter("InstanceStatus", std::to_string(instanceStatus));
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getDedicatedHostName()const
+{
+	return dedicatedHostName_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setDedicatedHostName(const std::string& dedicatedHostName)
+{
+	dedicatedHostName_ = dedicatedHostName;
+	setParameter("DedicatedHostName", dedicatedHostName);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getInstanceNetType()const
+{
+	return instanceNetType_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setInstanceNetType(const std::string& instanceNetType)
+{
+	instanceNetType_ = instanceNetType;
+	setParameter("InstanceNetType", instanceNetType);
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+long DescribeDedicatedClusterInstanceListRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDedicatedClusterInstanceListRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeDedicatedClusterInstanceListRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

dds/src/model/DescribeDedicatedClusterInstanceListResult.cc

@@ -0,0 +1,138 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/dds/model/DescribeDedicatedClusterInstanceListResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dds;
+using namespace AlibabaCloud::Dds::Model;
+
+DescribeDedicatedClusterInstanceListResult::DescribeDedicatedClusterInstanceListResult() :
+	ServiceResult()
+{}
+
+DescribeDedicatedClusterInstanceListResult::DescribeDedicatedClusterInstanceListResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDedicatedClusterInstanceListResult::~DescribeDedicatedClusterInstanceListResult()
+{}
+
+void DescribeDedicatedClusterInstanceListResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allInstancesNode = value["Instances"]["dbInstance"];
+	for (auto valueInstancesdbInstance : allInstancesNode)
+	{
+		DbInstance instancesObject;
+		if(!valueInstancesdbInstance["Region"].isNull())
+			instancesObject.region = valueInstancesdbInstance["Region"].asString();
+		if(!valueInstancesdbInstance["ClusterId"].isNull())
+			instancesObject.clusterId = valueInstancesdbInstance["ClusterId"].asString();
+		if(!valueInstancesdbInstance["ClusterName"].isNull())
+			instancesObject.clusterName = valueInstancesdbInstance["ClusterName"].asString();
+		if(!valueInstancesdbInstance["InstanceId"].isNull())
+			instancesObject.instanceId = valueInstancesdbInstance["InstanceId"].asString();
+		if(!valueInstancesdbInstance["InstanceName"].isNull())
+			instancesObject.instanceName = valueInstancesdbInstance["InstanceName"].asString();
+		if(!valueInstancesdbInstance["InstanceStatus"].isNull())
+			instancesObject.instanceStatus = valueInstancesdbInstance["InstanceStatus"].asString();
+		if(!valueInstancesdbInstance["EngineVersion"].isNull())
+			instancesObject.engineVersion = valueInstancesdbInstance["EngineVersion"].asString();
+		if(!valueInstancesdbInstance["CharacterType"].isNull())
+			instancesObject.characterType = std::stoi(valueInstancesdbInstance["CharacterType"].asString());
+		if(!valueInstancesdbInstance["MaintainStartTime"].isNull())
+			instancesObject.maintainStartTime = valueInstancesdbInstance["MaintainStartTime"].asString();
+		if(!valueInstancesdbInstance["MaintainEndTime"].isNull())
+			instancesObject.maintainEndTime = valueInstancesdbInstance["MaintainEndTime"].asString();
+		if(!valueInstancesdbInstance["RegionId"].isNull())
+			instancesObject.regionId = valueInstancesdbInstance["RegionId"].asString();
+		if(!valueInstancesdbInstance["VpcId"].isNull())
+			instancesObject.vpcId = valueInstancesdbInstance["VpcId"].asString();
+		if(!valueInstancesdbInstance["VswitchId"].isNull())
+			instancesObject.vswitchId = valueInstancesdbInstance["VswitchId"].asString();
+		if(!valueInstancesdbInstance["ZoneId"].isNull())
+			instancesObject.zoneId = valueInstancesdbInstance["ZoneId"].asString();
+		if(!valueInstancesdbInstance["CustomId"].isNull())
+			instancesObject.customId = valueInstancesdbInstance["CustomId"].asString();
+		if(!valueInstancesdbInstance["InstanceClass"].isNull())
+			instancesObject.instanceClass = valueInstancesdbInstance["InstanceClass"].asString();
+		if(!valueInstancesdbInstance["Engine"].isNull())
+			instancesObject.engine = valueInstancesdbInstance["Engine"].asString();
+		if(!valueInstancesdbInstance["StorageType"].isNull())
+			instancesObject.storageType = valueInstancesdbInstance["StorageType"].asString();
+		if(!valueInstancesdbInstance["ConnectionDomain"].isNull())
+			instancesObject.connectionDomain = valueInstancesdbInstance["ConnectionDomain"].asString();
+		if(!valueInstancesdbInstance["CreateTime"].isNull())
+			instancesObject.createTime = valueInstancesdbInstance["CreateTime"].asString();
+		auto allInstanceNodeListNode = allInstancesNode["InstanceNodeList"]["InstanceNodes"];
+		for (auto allInstancesNodeInstanceNodeListInstanceNodes : allInstanceNodeListNode)
+		{
+			DbInstance::InstanceNodes instanceNodeListObject;
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["InsName"].isNull())
+				instanceNodeListObject.insName = allInstancesNodeInstanceNodeListInstanceNodes["InsName"].asString();
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["Role"].isNull())
+				instanceNodeListObject.role = allInstancesNodeInstanceNodeListInstanceNodes["Role"].asString();
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["NodeId"].isNull())
+				instanceNodeListObject.nodeId = std::stoi(allInstancesNodeInstanceNodeListInstanceNodes["NodeId"].asString());
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["NodeType"].isNull())
+				instanceNodeListObject.nodeType = allInstancesNodeInstanceNodeListInstanceNodes["NodeType"].asString();
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["NodeIp"].isNull())
+				instanceNodeListObject.nodeIp = allInstancesNodeInstanceNodeListInstanceNodes["NodeIp"].asString();
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["Port"].isNull())
+				instanceNodeListObject.port = std::stoi(allInstancesNodeInstanceNodeListInstanceNodes["Port"].asString());
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["ZoneId"].isNull())
+				instanceNodeListObject.zoneId = allInstancesNodeInstanceNodeListInstanceNodes["ZoneId"].asString();
+			if(!allInstancesNodeInstanceNodeListInstanceNodes["DedicatedHostName"].isNull())
+				instanceNodeListObject.dedicatedHostName = allInstancesNodeInstanceNodeListInstanceNodes["DedicatedHostName"].asString();
+			instancesObject.instanceNodeList.push_back(instanceNodeListObject);
+		}
+		instances_.push_back(instancesObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+std::vector<DescribeDedicatedClusterInstanceListResult::DbInstance> DescribeDedicatedClusterInstanceListResult::getInstances()const
+{
+	return instances_;
+}
+
+int DescribeDedicatedClusterInstanceListResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeDedicatedClusterInstanceListResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeDedicatedClusterInstanceListResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

dds/src/model/DescribeRegionsResult.cc

@@ -55,6 +55,8 @@ void DescribeRegionsResult::parse(const std::string &payload)
 				zonesObject.zoneId = allRegionsNodeZonesZone["ZoneId"].asString();
 			if(!allRegionsNodeZonesZone["VpcEnabled"].isNull())
 				zonesObject.vpcEnabled = allRegionsNodeZonesZone["VpcEnabled"].asString() == "true";
+			if(!allRegionsNodeZonesZone["ZoneName"].isNull())
+				zonesObject.zoneName = allRegionsNodeZonesZone["ZoneName"].asString();
 			regionsObject.zones.push_back(zonesObject);
 		}
 		regions_.push_back(regionsObject);

ecs/include/alibabacloud/ecs/model/CreateCapacityReservationRequest.h

@@ -73,6 +73,8 @@ namespace AlibabaCloud
 				void setResourceType(const std::string& resourceType);
 				std::string getPeriodUnit()const;
 				void setPeriodUnit(const std::string& periodUnit);
+				std::string getTimeSlot()const;
+				void setTimeSlot(const std::string& timeSlot);
 				std::vector<std::string> getZoneId()const;
 				void setZoneId(const std::vector<std::string>& zoneId);
 				std::string getChargeType()const;
@@ -102,6 +104,7 @@ namespace AlibabaCloud
 				long ownerId_;
 				std::string resourceType_;
 				std::string periodUnit_;
+				std::string timeSlot_;
 				std::vector<std::string> zoneId_;
 				std::string chargeType_;
 				std::string packageType_;

ecs/include/alibabacloud/ecs/model/DescribeInstancesResult.h

@@ -143,6 +143,7 @@ namespace AlibabaCloud
 					std::string zoneId;
 					std::string clusterId;
 					std::string hpcClusterId;
+					std::string iSP;
 					int deploymentSetGroupNo;
 					EcsCapacityReservationAttr ecsCapacityReservationAttr;
 					DedicatedHostAttribute dedicatedHostAttribute;

ecs/include/alibabacloud/ecs/model/DescribePriceRequest.h

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setResourceOwnerId(long resourceOwnerId);
 				std::string getDataDisk3Category()const;
 				void setDataDisk3Category(const std::string& dataDisk3Category);
+				std::string getIsp()const;
+				void setIsp(const std::string& isp);
 				int getDataDisk4Size()const;
 				void setDataDisk4Size(int dataDisk4Size);
 				std::string getPriceUnit()const;
@@ -116,6 +118,7 @@ namespace AlibabaCloud
 				int dataDisk3Size_;
 				long resourceOwnerId_;
 				std::string dataDisk3Category_;
+				std::string isp_;
 				int dataDisk4Size_;
 				std::string priceUnit_;
 				int period_;

ecs/include/alibabacloud/ecs/model/ModifyInstanceNetworkSpecRequest.h

@@ -39,6 +39,8 @@ namespace AlibabaCloud
 				void setResourceOwnerId(long resourceOwnerId);
 				std::string getClientToken()const;
 				void setClientToken(const std::string& clientToken);
+				std::string getISP()const;
+				void setISP(const std::string& iSP);
 				int getInternetMaxBandwidthOut()const;
 				void setInternetMaxBandwidthOut(int internetMaxBandwidthOut);
 				std::string getStartTime()const;
@@ -65,6 +67,7 @@ namespace AlibabaCloud
             private:
 				long resourceOwnerId_;
 				std::string clientToken_;
+				std::string iSP_;
 				int internetMaxBandwidthOut_;
 				std::string startTime_;
 				bool autoPay_;

ecs/include/alibabacloud/ecs/model/RunInstancesRequest.h

@@ -160,6 +160,8 @@ namespace AlibabaCloud
 				void setHpcClusterId(const std::string& hpcClusterId);
 				int getHttpPutResponseHopLimit()const;
 				void setHttpPutResponseHopLimit(int httpPutResponseHopLimit);
+				std::string getIsp()const;
+				void setIsp(const std::string& isp);
 				std::string getKeyPairName()const;
 				void setKeyPairName(const std::string& keyPairName);
 				float getSpotPriceLimit()const;
@@ -280,6 +282,7 @@ namespace AlibabaCloud
 				long resourceOwnerId_;
 				std::string hpcClusterId_;
 				int httpPutResponseHopLimit_;
+				std::string isp_;
 				std::string keyPairName_;
 				float spotPriceLimit_;
 				int storageSetPartitionNumber_;

ecs/src/EcsClient.cc

@@ -31,21 +31,21 @@ EcsClient::EcsClient(const Credentials &credentials, const ClientConfiguration &
 	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, "ecs");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 EcsClient::EcsClient(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, "ecs");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 EcsClient::EcsClient(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, "ecs");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 EcsClient::~EcsClient()

ecs/src/model/CreateCapacityReservationRequest.cc

@@ -236,6 +236,17 @@ void CreateCapacityReservationRequest::setPeriodUnit(const std::string& periodUn
 	setParameter("PeriodUnit", periodUnit);
 }
 
+std::string CreateCapacityReservationRequest::getTimeSlot()const
+{
+	return timeSlot_;
+}
+
+void CreateCapacityReservationRequest::setTimeSlot(const std::string& timeSlot)
+{
+	timeSlot_ = timeSlot;
+	setParameter("TimeSlot", timeSlot);
+}
+
 std::vector<std::string> CreateCapacityReservationRequest::getZoneId()const
 {
 	return zoneId_;

ecs/src/model/DescribeAccountAttributesResult.cc

@@ -45,24 +45,24 @@ void DescribeAccountAttributesResult::parse(const std::string &payload)
 		AccountAttributeItem accountAttributeItemsObject;
 		if(!valueAccountAttributeItemsAccountAttributeItem["AttributeName"].isNull())
 			accountAttributeItemsObject.attributeName = valueAccountAttributeItemsAccountAttributeItem["AttributeName"].asString();
-		auto allAttributeValuesNode = allAccountAttributeItemsNode["AttributeValues"]["ValueItem"];
-		for (auto allAccountAttributeItemsNodeAttributeValuesValueItem : allAttributeValuesNode)
+		auto allAttributeValuesNode = valueAccountAttributeItemsAccountAttributeItem["AttributeValues"]["ValueItem"];
+		for (auto valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem : allAttributeValuesNode)
 		{
 			AccountAttributeItem::ValueItem attributeValuesObject;
-			if(!allAccountAttributeItemsNodeAttributeValuesValueItem["Value"].isNull())
-				attributeValuesObject.value = allAccountAttributeItemsNodeAttributeValuesValueItem["Value"].asString();
-			if(!allAccountAttributeItemsNodeAttributeValuesValueItem["ExpiredTime"].isNull())
-				attributeValuesObject.expiredTime = allAccountAttributeItemsNodeAttributeValuesValueItem["ExpiredTime"].asString();
-			if(!allAccountAttributeItemsNodeAttributeValuesValueItem["ZoneId"].isNull())
-				attributeValuesObject.zoneId = allAccountAttributeItemsNodeAttributeValuesValueItem["ZoneId"].asString();
-			if(!allAccountAttributeItemsNodeAttributeValuesValueItem["InstanceChargeType"].isNull())
-				attributeValuesObject.instanceChargeType = allAccountAttributeItemsNodeAttributeValuesValueItem["InstanceChargeType"].asString();
-			if(!allAccountAttributeItemsNodeAttributeValuesValueItem["InstanceType"].isNull())
-				attributeValuesObject.instanceType = allAccountAttributeItemsNodeAttributeValuesValueItem["InstanceType"].asString();
-			if(!allAccountAttributeItemsNodeAttributeValuesValueItem["Count"].isNull())
-				attributeValuesObject.count = std::stoi(allAccountAttributeItemsNodeAttributeValuesValueItem["Count"].asString());
-			if(!allAccountAttributeItemsNodeAttributeValuesValueItem["DiskCategory"].isNull())
-				attributeValuesObject.diskCategory = allAccountAttributeItemsNodeAttributeValuesValueItem["DiskCategory"].asString();
+			if(!valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["Value"].isNull())
+				attributeValuesObject.value = valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["Value"].asString();
+			if(!valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["ExpiredTime"].isNull())
+				attributeValuesObject.expiredTime = valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["ExpiredTime"].asString();
+			if(!valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["ZoneId"].isNull())
+				attributeValuesObject.zoneId = valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["ZoneId"].asString();
+			if(!valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["InstanceChargeType"].isNull())
+				attributeValuesObject.instanceChargeType = valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["InstanceChargeType"].asString();
+			if(!valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["InstanceType"].isNull())
+				attributeValuesObject.instanceType = valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["InstanceType"].asString();
+			if(!valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["Count"].isNull())
+				attributeValuesObject.count = std::stoi(valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["Count"].asString());
+			if(!valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["DiskCategory"].isNull())
+				attributeValuesObject.diskCategory = valueAccountAttributeItemsAccountAttributeItemAttributeValuesValueItem["DiskCategory"].asString();
 			accountAttributeItemsObject.attributeValues.push_back(attributeValuesObject);
 		}
 		accountAttributeItems_.push_back(accountAttributeItemsObject);

ecs/src/model/DescribeAutoProvisioningGroupHistoryResult.cc

@@ -51,14 +51,14 @@ void DescribeAutoProvisioningGroupHistoryResult::parse(const std::string &payloa
 			autoProvisioningGroupHistoriesObject.lastEventTime = valueAutoProvisioningGroupHistoriesAutoProvisioningGroupHistory["LastEventTime"].asString();
 		if(!valueAutoProvisioningGroupHistoriesAutoProvisioningGroupHistory["StartTime"].isNull())
 			autoProvisioningGroupHistoriesObject.startTime = valueAutoProvisioningGroupHistoriesAutoProvisioningGroupHistory["StartTime"].asString();
-		auto allActivityDetailsNode = allAutoProvisioningGroupHistoriesNode["ActivityDetails"]["ActivityDetail"];
-		for (auto allAutoProvisioningGroupHistoriesNodeActivityDetailsActivityDetail : allActivityDetailsNode)
+		auto allActivityDetailsNode = valueAutoProvisioningGroupHistoriesAutoProvisioningGroupHistory["ActivityDetails"]["ActivityDetail"];
+		for (auto valueAutoProvisioningGroupHistoriesAutoProvisioningGroupHistoryActivityDetailsActivityDetail : allActivityDetailsNode)
 		{
 			AutoProvisioningGroupHistory::ActivityDetail activityDetailsObject;
-			if(!allAutoProvisioningGroupHistoriesNodeActivityDetailsActivityDetail["Detail"].isNull())
-				activityDetailsObject.detail = allAutoProvisioningGroupHistoriesNodeActivityDetailsActivityDetail["Detail"].asString();
-			if(!allAutoProvisioningGroupHistoriesNodeActivityDetailsActivityDetail["Status"].isNull())
-				activityDetailsObject.status = allAutoProvisioningGroupHistoriesNodeActivityDetailsActivityDetail["Status"].asString();
+			if(!valueAutoProvisioningGroupHistoriesAutoProvisioningGroupHistoryActivityDetailsActivityDetail["Detail"].isNull())
+				activityDetailsObject.detail = valueAutoProvisioningGroupHistoriesAutoProvisioningGroupHistoryActivityDetailsActivityDetail["Detail"].asString();
+			if(!valueAutoProvisioningGroupHistoriesAutoProvisioningGroupHistoryActivityDetailsActivityDetail["Status"].isNull())
+				activityDetailsObject.status = valueAutoProvisioningGroupHistoriesAutoProvisioningGroupHistoryActivityDetailsActivityDetail["Status"].asString();
 			autoProvisioningGroupHistoriesObject.activityDetails.push_back(activityDetailsObject);
 		}
 		autoProvisioningGroupHistories_.push_back(autoProvisioningGroupHistoriesObject);

ecs/src/model/DescribeAutoProvisioningGroupsResult.cc

@@ -73,20 +73,20 @@ void DescribeAutoProvisioningGroupsResult::parse(const std::string &payload)
 			autoProvisioningGroupsObject.terminateInstancesWithExpiration = valueAutoProvisioningGroupsAutoProvisioningGroup["TerminateInstancesWithExpiration"].asString() == "true";
 		if(!valueAutoProvisioningGroupsAutoProvisioningGroup["CreationTime"].isNull())
 			autoProvisioningGroupsObject.creationTime = valueAutoProvisioningGroupsAutoProvisioningGroup["CreationTime"].asString();
-		auto allLaunchTemplateConfigsNode = allAutoProvisioningGroupsNode["LaunchTemplateConfigs"]["LaunchTemplateConfig"];
-		for (auto allAutoProvisioningGroupsNodeLaunchTemplateConfigsLaunchTemplateConfig : allLaunchTemplateConfigsNode)
+		auto allLaunchTemplateConfigsNode = valueAutoProvisioningGroupsAutoProvisioningGroup["LaunchTemplateConfigs"]["LaunchTemplateConfig"];
+		for (auto valueAutoProvisioningGroupsAutoProvisioningGroupLaunchTemplateConfigsLaunchTemplateConfig : allLaunchTemplateConfigsNode)
 		{
 			AutoProvisioningGroup::LaunchTemplateConfig launchTemplateConfigsObject;
-			if(!allAutoProvisioningGroupsNodeLaunchTemplateConfigsLaunchTemplateConfig["InstanceType"].isNull())
-				launchTemplateConfigsObject.instanceType = allAutoProvisioningGroupsNodeLaunchTemplateConfigsLaunchTemplateConfig["InstanceType"].asString();
-			if(!allAutoProvisioningGroupsNodeLaunchTemplateConfigsLaunchTemplateConfig["MaxPrice"].isNull())
-				launchTemplateConfigsObject.maxPrice = std::stof(allAutoProvisioningGroupsNodeLaunchTemplateConfigsLaunchTemplateConfig["MaxPrice"].asString());
-			if(!allAutoProvisioningGroupsNodeLaunchTemplateConfigsLaunchTemplateConfig["VSwitchId"].isNull())
-				launchTemplateConfigsObject.vSwitchId = allAutoProvisioningGroupsNodeLaunchTemplateConfigsLaunchTemplateConfig["VSwitchId"].asString();
-			if(!allAutoProvisioningGroupsNodeLaunchTemplateConfigsLaunchTemplateConfig["WeightedCapacity"].isNull())
-				launchTemplateConfigsObject.weightedCapacity = std::stof(allAutoProvisioningGroupsNodeLaunchTemplateConfigsLaunchTemplateConfig["WeightedCapacity"].asString());
-			if(!allAutoProvisioningGroupsNodeLaunchTemplateConfigsLaunchTemplateConfig["Priority"].isNull())
-				launchTemplateConfigsObject.priority = std::stof(allAutoProvisioningGroupsNodeLaunchTemplateConfigsLaunchTemplateConfig["Priority"].asString());
+			if(!valueAutoProvisioningGroupsAutoProvisioningGroupLaunchTemplateConfigsLaunchTemplateConfig["InstanceType"].isNull())
+				launchTemplateConfigsObject.instanceType = valueAutoProvisioningGroupsAutoProvisioningGroupLaunchTemplateConfigsLaunchTemplateConfig["InstanceType"].asString();
+			if(!valueAutoProvisioningGroupsAutoProvisioningGroupLaunchTemplateConfigsLaunchTemplateConfig["MaxPrice"].isNull())
+				launchTemplateConfigsObject.maxPrice = std::stof(valueAutoProvisioningGroupsAutoProvisioningGroupLaunchTemplateConfigsLaunchTemplateConfig["MaxPrice"].asString());
+			if(!valueAutoProvisioningGroupsAutoProvisioningGroupLaunchTemplateConfigsLaunchTemplateConfig["VSwitchId"].isNull())
+				launchTemplateConfigsObject.vSwitchId = valueAutoProvisioningGroupsAutoProvisioningGroupLaunchTemplateConfigsLaunchTemplateConfig["VSwitchId"].asString();
+			if(!valueAutoProvisioningGroupsAutoProvisioningGroupLaunchTemplateConfigsLaunchTemplateConfig["WeightedCapacity"].isNull())
+				launchTemplateConfigsObject.weightedCapacity = std::stof(valueAutoProvisioningGroupsAutoProvisioningGroupLaunchTemplateConfigsLaunchTemplateConfig["WeightedCapacity"].asString());
+			if(!valueAutoProvisioningGroupsAutoProvisioningGroupLaunchTemplateConfigsLaunchTemplateConfig["Priority"].isNull())
+				launchTemplateConfigsObject.priority = std::stof(valueAutoProvisioningGroupsAutoProvisioningGroupLaunchTemplateConfigsLaunchTemplateConfig["Priority"].asString());
 			autoProvisioningGroupsObject.launchTemplateConfigs.push_back(launchTemplateConfigsObject);
 		}
 		auto spotOptionsNode = value["SpotOptions"];