Supported adjust PTS scene speed.

VERSION

@@ -1 +1 @@
-1.36.1417
+1.36.1418

pts/CMakeLists.txt

@@ -0,0 +1,242 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(pts_public_header 
+	include/alibabacloud/pts/PTSClient.h
+	include/alibabacloud/pts/PTSExport.h )
+
+set(pts_public_header_model 
+	include/alibabacloud/pts/model/AdjustJMeterSceneSpeedRequest.h
+	include/alibabacloud/pts/model/AdjustJMeterSceneSpeedResult.h
+	include/alibabacloud/pts/model/CreatePtsSceneRequest.h
+	include/alibabacloud/pts/model/CreatePtsSceneResult.h
+	include/alibabacloud/pts/model/CreatePtsSceneBaseLineFromReportRequest.h
+	include/alibabacloud/pts/model/CreatePtsSceneBaseLineFromReportResult.h
+	include/alibabacloud/pts/model/DeletePtsSceneRequest.h
+	include/alibabacloud/pts/model/DeletePtsSceneResult.h
+	include/alibabacloud/pts/model/DeletePtsSceneBaseLineRequest.h
+	include/alibabacloud/pts/model/DeletePtsSceneBaseLineResult.h
+	include/alibabacloud/pts/model/DeletePtsScenesRequest.h
+	include/alibabacloud/pts/model/DeletePtsScenesResult.h
+	include/alibabacloud/pts/model/GetAllRegionsRequest.h
+	include/alibabacloud/pts/model/GetAllRegionsResult.h
+	include/alibabacloud/pts/model/GetJMeterLogsRequest.h
+	include/alibabacloud/pts/model/GetJMeterLogsResult.h
+	include/alibabacloud/pts/model/GetJMeterSampleMetricsRequest.h
+	include/alibabacloud/pts/model/GetJMeterSampleMetricsResult.h
+	include/alibabacloud/pts/model/GetJMeterSamplingLogsRequest.h
+	include/alibabacloud/pts/model/GetJMeterSamplingLogsResult.h
+	include/alibabacloud/pts/model/GetJMeterSceneRunningDataRequest.h
+	include/alibabacloud/pts/model/GetJMeterSceneRunningDataResult.h
+	include/alibabacloud/pts/model/GetOpenJMeterSceneRequest.h
+	include/alibabacloud/pts/model/GetOpenJMeterSceneResult.h
+	include/alibabacloud/pts/model/GetPtsReportDetailsRequest.h
+	include/alibabacloud/pts/model/GetPtsReportDetailsResult.h
+	include/alibabacloud/pts/model/GetPtsReportsBySceneIdRequest.h
+	include/alibabacloud/pts/model/GetPtsReportsBySceneIdResult.h
+	include/alibabacloud/pts/model/GetPtsSceneRequest.h
+	include/alibabacloud/pts/model/GetPtsSceneResult.h
+	include/alibabacloud/pts/model/GetPtsSceneBaseLineRequest.h
+	include/alibabacloud/pts/model/GetPtsSceneBaseLineResult.h
+	include/alibabacloud/pts/model/GetPtsSceneRunningDataRequest.h
+	include/alibabacloud/pts/model/GetPtsSceneRunningDataResult.h
+	include/alibabacloud/pts/model/GetPtsSceneRunningStatusRequest.h
+	include/alibabacloud/pts/model/GetPtsSceneRunningStatusResult.h
+	include/alibabacloud/pts/model/GetUserVpcSecurityGroupRequest.h
+	include/alibabacloud/pts/model/GetUserVpcSecurityGroupResult.h
+	include/alibabacloud/pts/model/GetUserVpcVSwitchRequest.h
+	include/alibabacloud/pts/model/GetUserVpcVSwitchResult.h
+	include/alibabacloud/pts/model/GetUserVpcsRequest.h
+	include/alibabacloud/pts/model/GetUserVpcsResult.h
+	include/alibabacloud/pts/model/ListEnvsRequest.h
+	include/alibabacloud/pts/model/ListEnvsResult.h
+	include/alibabacloud/pts/model/ListJMeterReportsRequest.h
+	include/alibabacloud/pts/model/ListJMeterReportsResult.h
+	include/alibabacloud/pts/model/ListOpenJMeterScenesRequest.h
+	include/alibabacloud/pts/model/ListOpenJMeterScenesResult.h
+	include/alibabacloud/pts/model/ListPtsSceneRequest.h
+	include/alibabacloud/pts/model/ListPtsSceneResult.h
+	include/alibabacloud/pts/model/ModifyPtsSceneRequest.h
+	include/alibabacloud/pts/model/ModifyPtsSceneResult.h
+	include/alibabacloud/pts/model/RemoveEnvRequest.h
+	include/alibabacloud/pts/model/RemoveEnvResult.h
+	include/alibabacloud/pts/model/RemoveOpenJMeterSceneRequest.h
+	include/alibabacloud/pts/model/RemoveOpenJMeterSceneResult.h
+	include/alibabacloud/pts/model/SaveEnvRequest.h
+	include/alibabacloud/pts/model/SaveEnvResult.h
+	include/alibabacloud/pts/model/SaveOpenJMeterSceneRequest.h
+	include/alibabacloud/pts/model/SaveOpenJMeterSceneResult.h
+	include/alibabacloud/pts/model/SavePtsSceneRequest.h
+	include/alibabacloud/pts/model/SavePtsSceneResult.h
+	include/alibabacloud/pts/model/StartDebugPtsSceneRequest.h
+	include/alibabacloud/pts/model/StartDebugPtsSceneResult.h
+	include/alibabacloud/pts/model/StartDebuggingJMeterSceneRequest.h
+	include/alibabacloud/pts/model/StartDebuggingJMeterSceneResult.h
+	include/alibabacloud/pts/model/StartPtsSceneRequest.h
+	include/alibabacloud/pts/model/StartPtsSceneResult.h
+	include/alibabacloud/pts/model/StartTestingJMeterSceneRequest.h
+	include/alibabacloud/pts/model/StartTestingJMeterSceneResult.h
+	include/alibabacloud/pts/model/StopDebugPtsSceneRequest.h
+	include/alibabacloud/pts/model/StopDebugPtsSceneResult.h
+	include/alibabacloud/pts/model/StopDebuggingJMeterSceneRequest.h
+	include/alibabacloud/pts/model/StopDebuggingJMeterSceneResult.h
+	include/alibabacloud/pts/model/StopPtsSceneRequest.h
+	include/alibabacloud/pts/model/StopPtsSceneResult.h
+	include/alibabacloud/pts/model/StopTestingJMeterSceneRequest.h
+	include/alibabacloud/pts/model/StopTestingJMeterSceneResult.h
+	include/alibabacloud/pts/model/UpdatePtsSceneBaseLineRequest.h
+	include/alibabacloud/pts/model/UpdatePtsSceneBaseLineResult.h )
+
+set(pts_src 
+	src/PTSClient.cc
+	src/model/AdjustJMeterSceneSpeedRequest.cc
+	src/model/AdjustJMeterSceneSpeedResult.cc
+	src/model/CreatePtsSceneRequest.cc
+	src/model/CreatePtsSceneResult.cc
+	src/model/CreatePtsSceneBaseLineFromReportRequest.cc
+	src/model/CreatePtsSceneBaseLineFromReportResult.cc
+	src/model/DeletePtsSceneRequest.cc
+	src/model/DeletePtsSceneResult.cc
+	src/model/DeletePtsSceneBaseLineRequest.cc
+	src/model/DeletePtsSceneBaseLineResult.cc
+	src/model/DeletePtsScenesRequest.cc
+	src/model/DeletePtsScenesResult.cc
+	src/model/GetAllRegionsRequest.cc
+	src/model/GetAllRegionsResult.cc
+	src/model/GetJMeterLogsRequest.cc
+	src/model/GetJMeterLogsResult.cc
+	src/model/GetJMeterSampleMetricsRequest.cc
+	src/model/GetJMeterSampleMetricsResult.cc
+	src/model/GetJMeterSamplingLogsRequest.cc
+	src/model/GetJMeterSamplingLogsResult.cc
+	src/model/GetJMeterSceneRunningDataRequest.cc
+	src/model/GetJMeterSceneRunningDataResult.cc
+	src/model/GetOpenJMeterSceneRequest.cc
+	src/model/GetOpenJMeterSceneResult.cc
+	src/model/GetPtsReportDetailsRequest.cc
+	src/model/GetPtsReportDetailsResult.cc
+	src/model/GetPtsReportsBySceneIdRequest.cc
+	src/model/GetPtsReportsBySceneIdResult.cc
+	src/model/GetPtsSceneRequest.cc
+	src/model/GetPtsSceneResult.cc
+	src/model/GetPtsSceneBaseLineRequest.cc
+	src/model/GetPtsSceneBaseLineResult.cc
+	src/model/GetPtsSceneRunningDataRequest.cc
+	src/model/GetPtsSceneRunningDataResult.cc
+	src/model/GetPtsSceneRunningStatusRequest.cc
+	src/model/GetPtsSceneRunningStatusResult.cc
+	src/model/GetUserVpcSecurityGroupRequest.cc
+	src/model/GetUserVpcSecurityGroupResult.cc
+	src/model/GetUserVpcVSwitchRequest.cc
+	src/model/GetUserVpcVSwitchResult.cc
+	src/model/GetUserVpcsRequest.cc
+	src/model/GetUserVpcsResult.cc
+	src/model/ListEnvsRequest.cc
+	src/model/ListEnvsResult.cc
+	src/model/ListJMeterReportsRequest.cc
+	src/model/ListJMeterReportsResult.cc
+	src/model/ListOpenJMeterScenesRequest.cc
+	src/model/ListOpenJMeterScenesResult.cc
+	src/model/ListPtsSceneRequest.cc
+	src/model/ListPtsSceneResult.cc
+	src/model/ModifyPtsSceneRequest.cc
+	src/model/ModifyPtsSceneResult.cc
+	src/model/RemoveEnvRequest.cc
+	src/model/RemoveEnvResult.cc
+	src/model/RemoveOpenJMeterSceneRequest.cc
+	src/model/RemoveOpenJMeterSceneResult.cc
+	src/model/SaveEnvRequest.cc
+	src/model/SaveEnvResult.cc
+	src/model/SaveOpenJMeterSceneRequest.cc
+	src/model/SaveOpenJMeterSceneResult.cc
+	src/model/SavePtsSceneRequest.cc
+	src/model/SavePtsSceneResult.cc
+	src/model/StartDebugPtsSceneRequest.cc
+	src/model/StartDebugPtsSceneResult.cc
+	src/model/StartDebuggingJMeterSceneRequest.cc
+	src/model/StartDebuggingJMeterSceneResult.cc
+	src/model/StartPtsSceneRequest.cc
+	src/model/StartPtsSceneResult.cc
+	src/model/StartTestingJMeterSceneRequest.cc
+	src/model/StartTestingJMeterSceneResult.cc
+	src/model/StopDebugPtsSceneRequest.cc
+	src/model/StopDebugPtsSceneResult.cc
+	src/model/StopDebuggingJMeterSceneRequest.cc
+	src/model/StopDebuggingJMeterSceneResult.cc
+	src/model/StopPtsSceneRequest.cc
+	src/model/StopPtsSceneResult.cc
+	src/model/StopTestingJMeterSceneRequest.cc
+	src/model/StopTestingJMeterSceneResult.cc
+	src/model/UpdatePtsSceneBaseLineRequest.cc
+	src/model/UpdatePtsSceneBaseLineResult.cc )
+
+add_library(pts ${LIB_TYPE}
+	${pts_public_header}
+	${pts_public_header_model}
+	${pts_src})
+
+set_target_properties(pts
+	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}pts
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(pts
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_PTS_LIBRARY)
+endif()
+
+target_include_directories(pts
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(pts
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(pts
+		jsoncpp)
+	target_include_directories(pts
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(pts
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(pts
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(pts
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(pts
+		jsoncpp)
+endif()
+
+install(FILES ${pts_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/pts)
+install(FILES ${pts_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/pts/model)
+install(TARGETS pts
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

pts/include/alibabacloud/pts/PTSClient.h

@@ -0,0 +1,366 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_PTS_PTSCLIENT_H_
+#define ALIBABACLOUD_PTS_PTSCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "PTSExport.h"
+#include "model/AdjustJMeterSceneSpeedRequest.h"
+#include "model/AdjustJMeterSceneSpeedResult.h"
+#include "model/CreatePtsSceneRequest.h"
+#include "model/CreatePtsSceneResult.h"
+#include "model/CreatePtsSceneBaseLineFromReportRequest.h"
+#include "model/CreatePtsSceneBaseLineFromReportResult.h"
+#include "model/DeletePtsSceneRequest.h"
+#include "model/DeletePtsSceneResult.h"
+#include "model/DeletePtsSceneBaseLineRequest.h"
+#include "model/DeletePtsSceneBaseLineResult.h"
+#include "model/DeletePtsScenesRequest.h"
+#include "model/DeletePtsScenesResult.h"
+#include "model/GetAllRegionsRequest.h"
+#include "model/GetAllRegionsResult.h"
+#include "model/GetJMeterLogsRequest.h"
+#include "model/GetJMeterLogsResult.h"
+#include "model/GetJMeterSampleMetricsRequest.h"
+#include "model/GetJMeterSampleMetricsResult.h"
+#include "model/GetJMeterSamplingLogsRequest.h"
+#include "model/GetJMeterSamplingLogsResult.h"
+#include "model/GetJMeterSceneRunningDataRequest.h"
+#include "model/GetJMeterSceneRunningDataResult.h"
+#include "model/GetOpenJMeterSceneRequest.h"
+#include "model/GetOpenJMeterSceneResult.h"
+#include "model/GetPtsReportDetailsRequest.h"
+#include "model/GetPtsReportDetailsResult.h"
+#include "model/GetPtsReportsBySceneIdRequest.h"
+#include "model/GetPtsReportsBySceneIdResult.h"
+#include "model/GetPtsSceneRequest.h"
+#include "model/GetPtsSceneResult.h"
+#include "model/GetPtsSceneBaseLineRequest.h"
+#include "model/GetPtsSceneBaseLineResult.h"
+#include "model/GetPtsSceneRunningDataRequest.h"
+#include "model/GetPtsSceneRunningDataResult.h"
+#include "model/GetPtsSceneRunningStatusRequest.h"
+#include "model/GetPtsSceneRunningStatusResult.h"
+#include "model/GetUserVpcSecurityGroupRequest.h"
+#include "model/GetUserVpcSecurityGroupResult.h"
+#include "model/GetUserVpcVSwitchRequest.h"
+#include "model/GetUserVpcVSwitchResult.h"
+#include "model/GetUserVpcsRequest.h"
+#include "model/GetUserVpcsResult.h"
+#include "model/ListEnvsRequest.h"
+#include "model/ListEnvsResult.h"
+#include "model/ListJMeterReportsRequest.h"
+#include "model/ListJMeterReportsResult.h"
+#include "model/ListOpenJMeterScenesRequest.h"
+#include "model/ListOpenJMeterScenesResult.h"
+#include "model/ListPtsSceneRequest.h"
+#include "model/ListPtsSceneResult.h"
+#include "model/ModifyPtsSceneRequest.h"
+#include "model/ModifyPtsSceneResult.h"
+#include "model/RemoveEnvRequest.h"
+#include "model/RemoveEnvResult.h"
+#include "model/RemoveOpenJMeterSceneRequest.h"
+#include "model/RemoveOpenJMeterSceneResult.h"
+#include "model/SaveEnvRequest.h"
+#include "model/SaveEnvResult.h"
+#include "model/SaveOpenJMeterSceneRequest.h"
+#include "model/SaveOpenJMeterSceneResult.h"
+#include "model/SavePtsSceneRequest.h"
+#include "model/SavePtsSceneResult.h"
+#include "model/StartDebugPtsSceneRequest.h"
+#include "model/StartDebugPtsSceneResult.h"
+#include "model/StartDebuggingJMeterSceneRequest.h"
+#include "model/StartDebuggingJMeterSceneResult.h"
+#include "model/StartPtsSceneRequest.h"
+#include "model/StartPtsSceneResult.h"
+#include "model/StartTestingJMeterSceneRequest.h"
+#include "model/StartTestingJMeterSceneResult.h"
+#include "model/StopDebugPtsSceneRequest.h"
+#include "model/StopDebugPtsSceneResult.h"
+#include "model/StopDebuggingJMeterSceneRequest.h"
+#include "model/StopDebuggingJMeterSceneResult.h"
+#include "model/StopPtsSceneRequest.h"
+#include "model/StopPtsSceneResult.h"
+#include "model/StopTestingJMeterSceneRequest.h"
+#include "model/StopTestingJMeterSceneResult.h"
+#include "model/UpdatePtsSceneBaseLineRequest.h"
+#include "model/UpdatePtsSceneBaseLineResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		class ALIBABACLOUD_PTS_EXPORT PTSClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AdjustJMeterSceneSpeedResult> AdjustJMeterSceneSpeedOutcome;
+			typedef std::future<AdjustJMeterSceneSpeedOutcome> AdjustJMeterSceneSpeedOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::AdjustJMeterSceneSpeedRequest&, const AdjustJMeterSceneSpeedOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AdjustJMeterSceneSpeedAsyncHandler;
+			typedef Outcome<Error, Model::CreatePtsSceneResult> CreatePtsSceneOutcome;
+			typedef std::future<CreatePtsSceneOutcome> CreatePtsSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::CreatePtsSceneRequest&, const CreatePtsSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePtsSceneAsyncHandler;
+			typedef Outcome<Error, Model::CreatePtsSceneBaseLineFromReportResult> CreatePtsSceneBaseLineFromReportOutcome;
+			typedef std::future<CreatePtsSceneBaseLineFromReportOutcome> CreatePtsSceneBaseLineFromReportOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::CreatePtsSceneBaseLineFromReportRequest&, const CreatePtsSceneBaseLineFromReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePtsSceneBaseLineFromReportAsyncHandler;
+			typedef Outcome<Error, Model::DeletePtsSceneResult> DeletePtsSceneOutcome;
+			typedef std::future<DeletePtsSceneOutcome> DeletePtsSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::DeletePtsSceneRequest&, const DeletePtsSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePtsSceneAsyncHandler;
+			typedef Outcome<Error, Model::DeletePtsSceneBaseLineResult> DeletePtsSceneBaseLineOutcome;
+			typedef std::future<DeletePtsSceneBaseLineOutcome> DeletePtsSceneBaseLineOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::DeletePtsSceneBaseLineRequest&, const DeletePtsSceneBaseLineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePtsSceneBaseLineAsyncHandler;
+			typedef Outcome<Error, Model::DeletePtsScenesResult> DeletePtsScenesOutcome;
+			typedef std::future<DeletePtsScenesOutcome> DeletePtsScenesOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::DeletePtsScenesRequest&, const DeletePtsScenesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePtsScenesAsyncHandler;
+			typedef Outcome<Error, Model::GetAllRegionsResult> GetAllRegionsOutcome;
+			typedef std::future<GetAllRegionsOutcome> GetAllRegionsOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetAllRegionsRequest&, const GetAllRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAllRegionsAsyncHandler;
+			typedef Outcome<Error, Model::GetJMeterLogsResult> GetJMeterLogsOutcome;
+			typedef std::future<GetJMeterLogsOutcome> GetJMeterLogsOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetJMeterLogsRequest&, const GetJMeterLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetJMeterLogsAsyncHandler;
+			typedef Outcome<Error, Model::GetJMeterSampleMetricsResult> GetJMeterSampleMetricsOutcome;
+			typedef std::future<GetJMeterSampleMetricsOutcome> GetJMeterSampleMetricsOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetJMeterSampleMetricsRequest&, const GetJMeterSampleMetricsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetJMeterSampleMetricsAsyncHandler;
+			typedef Outcome<Error, Model::GetJMeterSamplingLogsResult> GetJMeterSamplingLogsOutcome;
+			typedef std::future<GetJMeterSamplingLogsOutcome> GetJMeterSamplingLogsOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetJMeterSamplingLogsRequest&, const GetJMeterSamplingLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetJMeterSamplingLogsAsyncHandler;
+			typedef Outcome<Error, Model::GetJMeterSceneRunningDataResult> GetJMeterSceneRunningDataOutcome;
+			typedef std::future<GetJMeterSceneRunningDataOutcome> GetJMeterSceneRunningDataOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetJMeterSceneRunningDataRequest&, const GetJMeterSceneRunningDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetJMeterSceneRunningDataAsyncHandler;
+			typedef Outcome<Error, Model::GetOpenJMeterSceneResult> GetOpenJMeterSceneOutcome;
+			typedef std::future<GetOpenJMeterSceneOutcome> GetOpenJMeterSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetOpenJMeterSceneRequest&, const GetOpenJMeterSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetOpenJMeterSceneAsyncHandler;
+			typedef Outcome<Error, Model::GetPtsReportDetailsResult> GetPtsReportDetailsOutcome;
+			typedef std::future<GetPtsReportDetailsOutcome> GetPtsReportDetailsOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetPtsReportDetailsRequest&, const GetPtsReportDetailsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPtsReportDetailsAsyncHandler;
+			typedef Outcome<Error, Model::GetPtsReportsBySceneIdResult> GetPtsReportsBySceneIdOutcome;
+			typedef std::future<GetPtsReportsBySceneIdOutcome> GetPtsReportsBySceneIdOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetPtsReportsBySceneIdRequest&, const GetPtsReportsBySceneIdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPtsReportsBySceneIdAsyncHandler;
+			typedef Outcome<Error, Model::GetPtsSceneResult> GetPtsSceneOutcome;
+			typedef std::future<GetPtsSceneOutcome> GetPtsSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetPtsSceneRequest&, const GetPtsSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPtsSceneAsyncHandler;
+			typedef Outcome<Error, Model::GetPtsSceneBaseLineResult> GetPtsSceneBaseLineOutcome;
+			typedef std::future<GetPtsSceneBaseLineOutcome> GetPtsSceneBaseLineOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetPtsSceneBaseLineRequest&, const GetPtsSceneBaseLineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPtsSceneBaseLineAsyncHandler;
+			typedef Outcome<Error, Model::GetPtsSceneRunningDataResult> GetPtsSceneRunningDataOutcome;
+			typedef std::future<GetPtsSceneRunningDataOutcome> GetPtsSceneRunningDataOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetPtsSceneRunningDataRequest&, const GetPtsSceneRunningDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPtsSceneRunningDataAsyncHandler;
+			typedef Outcome<Error, Model::GetPtsSceneRunningStatusResult> GetPtsSceneRunningStatusOutcome;
+			typedef std::future<GetPtsSceneRunningStatusOutcome> GetPtsSceneRunningStatusOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetPtsSceneRunningStatusRequest&, const GetPtsSceneRunningStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPtsSceneRunningStatusAsyncHandler;
+			typedef Outcome<Error, Model::GetUserVpcSecurityGroupResult> GetUserVpcSecurityGroupOutcome;
+			typedef std::future<GetUserVpcSecurityGroupOutcome> GetUserVpcSecurityGroupOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetUserVpcSecurityGroupRequest&, const GetUserVpcSecurityGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetUserVpcSecurityGroupAsyncHandler;
+			typedef Outcome<Error, Model::GetUserVpcVSwitchResult> GetUserVpcVSwitchOutcome;
+			typedef std::future<GetUserVpcVSwitchOutcome> GetUserVpcVSwitchOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetUserVpcVSwitchRequest&, const GetUserVpcVSwitchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetUserVpcVSwitchAsyncHandler;
+			typedef Outcome<Error, Model::GetUserVpcsResult> GetUserVpcsOutcome;
+			typedef std::future<GetUserVpcsOutcome> GetUserVpcsOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::GetUserVpcsRequest&, const GetUserVpcsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetUserVpcsAsyncHandler;
+			typedef Outcome<Error, Model::ListEnvsResult> ListEnvsOutcome;
+			typedef std::future<ListEnvsOutcome> ListEnvsOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::ListEnvsRequest&, const ListEnvsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListEnvsAsyncHandler;
+			typedef Outcome<Error, Model::ListJMeterReportsResult> ListJMeterReportsOutcome;
+			typedef std::future<ListJMeterReportsOutcome> ListJMeterReportsOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::ListJMeterReportsRequest&, const ListJMeterReportsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListJMeterReportsAsyncHandler;
+			typedef Outcome<Error, Model::ListOpenJMeterScenesResult> ListOpenJMeterScenesOutcome;
+			typedef std::future<ListOpenJMeterScenesOutcome> ListOpenJMeterScenesOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::ListOpenJMeterScenesRequest&, const ListOpenJMeterScenesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListOpenJMeterScenesAsyncHandler;
+			typedef Outcome<Error, Model::ListPtsSceneResult> ListPtsSceneOutcome;
+			typedef std::future<ListPtsSceneOutcome> ListPtsSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::ListPtsSceneRequest&, const ListPtsSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPtsSceneAsyncHandler;
+			typedef Outcome<Error, Model::ModifyPtsSceneResult> ModifyPtsSceneOutcome;
+			typedef std::future<ModifyPtsSceneOutcome> ModifyPtsSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::ModifyPtsSceneRequest&, const ModifyPtsSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyPtsSceneAsyncHandler;
+			typedef Outcome<Error, Model::RemoveEnvResult> RemoveEnvOutcome;
+			typedef std::future<RemoveEnvOutcome> RemoveEnvOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::RemoveEnvRequest&, const RemoveEnvOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveEnvAsyncHandler;
+			typedef Outcome<Error, Model::RemoveOpenJMeterSceneResult> RemoveOpenJMeterSceneOutcome;
+			typedef std::future<RemoveOpenJMeterSceneOutcome> RemoveOpenJMeterSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::RemoveOpenJMeterSceneRequest&, const RemoveOpenJMeterSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveOpenJMeterSceneAsyncHandler;
+			typedef Outcome<Error, Model::SaveEnvResult> SaveEnvOutcome;
+			typedef std::future<SaveEnvOutcome> SaveEnvOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::SaveEnvRequest&, const SaveEnvOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SaveEnvAsyncHandler;
+			typedef Outcome<Error, Model::SaveOpenJMeterSceneResult> SaveOpenJMeterSceneOutcome;
+			typedef std::future<SaveOpenJMeterSceneOutcome> SaveOpenJMeterSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::SaveOpenJMeterSceneRequest&, const SaveOpenJMeterSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SaveOpenJMeterSceneAsyncHandler;
+			typedef Outcome<Error, Model::SavePtsSceneResult> SavePtsSceneOutcome;
+			typedef std::future<SavePtsSceneOutcome> SavePtsSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::SavePtsSceneRequest&, const SavePtsSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SavePtsSceneAsyncHandler;
+			typedef Outcome<Error, Model::StartDebugPtsSceneResult> StartDebugPtsSceneOutcome;
+			typedef std::future<StartDebugPtsSceneOutcome> StartDebugPtsSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::StartDebugPtsSceneRequest&, const StartDebugPtsSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartDebugPtsSceneAsyncHandler;
+			typedef Outcome<Error, Model::StartDebuggingJMeterSceneResult> StartDebuggingJMeterSceneOutcome;
+			typedef std::future<StartDebuggingJMeterSceneOutcome> StartDebuggingJMeterSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::StartDebuggingJMeterSceneRequest&, const StartDebuggingJMeterSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartDebuggingJMeterSceneAsyncHandler;
+			typedef Outcome<Error, Model::StartPtsSceneResult> StartPtsSceneOutcome;
+			typedef std::future<StartPtsSceneOutcome> StartPtsSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::StartPtsSceneRequest&, const StartPtsSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartPtsSceneAsyncHandler;
+			typedef Outcome<Error, Model::StartTestingJMeterSceneResult> StartTestingJMeterSceneOutcome;
+			typedef std::future<StartTestingJMeterSceneOutcome> StartTestingJMeterSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::StartTestingJMeterSceneRequest&, const StartTestingJMeterSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartTestingJMeterSceneAsyncHandler;
+			typedef Outcome<Error, Model::StopDebugPtsSceneResult> StopDebugPtsSceneOutcome;
+			typedef std::future<StopDebugPtsSceneOutcome> StopDebugPtsSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::StopDebugPtsSceneRequest&, const StopDebugPtsSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopDebugPtsSceneAsyncHandler;
+			typedef Outcome<Error, Model::StopDebuggingJMeterSceneResult> StopDebuggingJMeterSceneOutcome;
+			typedef std::future<StopDebuggingJMeterSceneOutcome> StopDebuggingJMeterSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::StopDebuggingJMeterSceneRequest&, const StopDebuggingJMeterSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopDebuggingJMeterSceneAsyncHandler;
+			typedef Outcome<Error, Model::StopPtsSceneResult> StopPtsSceneOutcome;
+			typedef std::future<StopPtsSceneOutcome> StopPtsSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::StopPtsSceneRequest&, const StopPtsSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopPtsSceneAsyncHandler;
+			typedef Outcome<Error, Model::StopTestingJMeterSceneResult> StopTestingJMeterSceneOutcome;
+			typedef std::future<StopTestingJMeterSceneOutcome> StopTestingJMeterSceneOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::StopTestingJMeterSceneRequest&, const StopTestingJMeterSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopTestingJMeterSceneAsyncHandler;
+			typedef Outcome<Error, Model::UpdatePtsSceneBaseLineResult> UpdatePtsSceneBaseLineOutcome;
+			typedef std::future<UpdatePtsSceneBaseLineOutcome> UpdatePtsSceneBaseLineOutcomeCallable;
+			typedef std::function<void(const PTSClient*, const Model::UpdatePtsSceneBaseLineRequest&, const UpdatePtsSceneBaseLineOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdatePtsSceneBaseLineAsyncHandler;
+
+			PTSClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			PTSClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			PTSClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~PTSClient();
+			AdjustJMeterSceneSpeedOutcome adjustJMeterSceneSpeed(const Model::AdjustJMeterSceneSpeedRequest &request)const;
+			void adjustJMeterSceneSpeedAsync(const Model::AdjustJMeterSceneSpeedRequest& request, const AdjustJMeterSceneSpeedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AdjustJMeterSceneSpeedOutcomeCallable adjustJMeterSceneSpeedCallable(const Model::AdjustJMeterSceneSpeedRequest& request) const;
+			CreatePtsSceneOutcome createPtsScene(const Model::CreatePtsSceneRequest &request)const;
+			void createPtsSceneAsync(const Model::CreatePtsSceneRequest& request, const CreatePtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreatePtsSceneOutcomeCallable createPtsSceneCallable(const Model::CreatePtsSceneRequest& request) const;
+			CreatePtsSceneBaseLineFromReportOutcome createPtsSceneBaseLineFromReport(const Model::CreatePtsSceneBaseLineFromReportRequest &request)const;
+			void createPtsSceneBaseLineFromReportAsync(const Model::CreatePtsSceneBaseLineFromReportRequest& request, const CreatePtsSceneBaseLineFromReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreatePtsSceneBaseLineFromReportOutcomeCallable createPtsSceneBaseLineFromReportCallable(const Model::CreatePtsSceneBaseLineFromReportRequest& request) const;
+			DeletePtsSceneOutcome deletePtsScene(const Model::DeletePtsSceneRequest &request)const;
+			void deletePtsSceneAsync(const Model::DeletePtsSceneRequest& request, const DeletePtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeletePtsSceneOutcomeCallable deletePtsSceneCallable(const Model::DeletePtsSceneRequest& request) const;
+			DeletePtsSceneBaseLineOutcome deletePtsSceneBaseLine(const Model::DeletePtsSceneBaseLineRequest &request)const;
+			void deletePtsSceneBaseLineAsync(const Model::DeletePtsSceneBaseLineRequest& request, const DeletePtsSceneBaseLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeletePtsSceneBaseLineOutcomeCallable deletePtsSceneBaseLineCallable(const Model::DeletePtsSceneBaseLineRequest& request) const;
+			DeletePtsScenesOutcome deletePtsScenes(const Model::DeletePtsScenesRequest &request)const;
+			void deletePtsScenesAsync(const Model::DeletePtsScenesRequest& request, const DeletePtsScenesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeletePtsScenesOutcomeCallable deletePtsScenesCallable(const Model::DeletePtsScenesRequest& request) const;
+			GetAllRegionsOutcome getAllRegions(const Model::GetAllRegionsRequest &request)const;
+			void getAllRegionsAsync(const Model::GetAllRegionsRequest& request, const GetAllRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAllRegionsOutcomeCallable getAllRegionsCallable(const Model::GetAllRegionsRequest& request) const;
+			GetJMeterLogsOutcome getJMeterLogs(const Model::GetJMeterLogsRequest &request)const;
+			void getJMeterLogsAsync(const Model::GetJMeterLogsRequest& request, const GetJMeterLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetJMeterLogsOutcomeCallable getJMeterLogsCallable(const Model::GetJMeterLogsRequest& request) const;
+			GetJMeterSampleMetricsOutcome getJMeterSampleMetrics(const Model::GetJMeterSampleMetricsRequest &request)const;
+			void getJMeterSampleMetricsAsync(const Model::GetJMeterSampleMetricsRequest& request, const GetJMeterSampleMetricsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetJMeterSampleMetricsOutcomeCallable getJMeterSampleMetricsCallable(const Model::GetJMeterSampleMetricsRequest& request) const;
+			GetJMeterSamplingLogsOutcome getJMeterSamplingLogs(const Model::GetJMeterSamplingLogsRequest &request)const;
+			void getJMeterSamplingLogsAsync(const Model::GetJMeterSamplingLogsRequest& request, const GetJMeterSamplingLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetJMeterSamplingLogsOutcomeCallable getJMeterSamplingLogsCallable(const Model::GetJMeterSamplingLogsRequest& request) const;
+			GetJMeterSceneRunningDataOutcome getJMeterSceneRunningData(const Model::GetJMeterSceneRunningDataRequest &request)const;
+			void getJMeterSceneRunningDataAsync(const Model::GetJMeterSceneRunningDataRequest& request, const GetJMeterSceneRunningDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetJMeterSceneRunningDataOutcomeCallable getJMeterSceneRunningDataCallable(const Model::GetJMeterSceneRunningDataRequest& request) const;
+			GetOpenJMeterSceneOutcome getOpenJMeterScene(const Model::GetOpenJMeterSceneRequest &request)const;
+			void getOpenJMeterSceneAsync(const Model::GetOpenJMeterSceneRequest& request, const GetOpenJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetOpenJMeterSceneOutcomeCallable getOpenJMeterSceneCallable(const Model::GetOpenJMeterSceneRequest& request) const;
+			GetPtsReportDetailsOutcome getPtsReportDetails(const Model::GetPtsReportDetailsRequest &request)const;
+			void getPtsReportDetailsAsync(const Model::GetPtsReportDetailsRequest& request, const GetPtsReportDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPtsReportDetailsOutcomeCallable getPtsReportDetailsCallable(const Model::GetPtsReportDetailsRequest& request) const;
+			GetPtsReportsBySceneIdOutcome getPtsReportsBySceneId(const Model::GetPtsReportsBySceneIdRequest &request)const;
+			void getPtsReportsBySceneIdAsync(const Model::GetPtsReportsBySceneIdRequest& request, const GetPtsReportsBySceneIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPtsReportsBySceneIdOutcomeCallable getPtsReportsBySceneIdCallable(const Model::GetPtsReportsBySceneIdRequest& request) const;
+			GetPtsSceneOutcome getPtsScene(const Model::GetPtsSceneRequest &request)const;
+			void getPtsSceneAsync(const Model::GetPtsSceneRequest& request, const GetPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPtsSceneOutcomeCallable getPtsSceneCallable(const Model::GetPtsSceneRequest& request) const;
+			GetPtsSceneBaseLineOutcome getPtsSceneBaseLine(const Model::GetPtsSceneBaseLineRequest &request)const;
+			void getPtsSceneBaseLineAsync(const Model::GetPtsSceneBaseLineRequest& request, const GetPtsSceneBaseLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPtsSceneBaseLineOutcomeCallable getPtsSceneBaseLineCallable(const Model::GetPtsSceneBaseLineRequest& request) const;
+			GetPtsSceneRunningDataOutcome getPtsSceneRunningData(const Model::GetPtsSceneRunningDataRequest &request)const;
+			void getPtsSceneRunningDataAsync(const Model::GetPtsSceneRunningDataRequest& request, const GetPtsSceneRunningDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPtsSceneRunningDataOutcomeCallable getPtsSceneRunningDataCallable(const Model::GetPtsSceneRunningDataRequest& request) const;
+			GetPtsSceneRunningStatusOutcome getPtsSceneRunningStatus(const Model::GetPtsSceneRunningStatusRequest &request)const;
+			void getPtsSceneRunningStatusAsync(const Model::GetPtsSceneRunningStatusRequest& request, const GetPtsSceneRunningStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPtsSceneRunningStatusOutcomeCallable getPtsSceneRunningStatusCallable(const Model::GetPtsSceneRunningStatusRequest& request) const;
+			GetUserVpcSecurityGroupOutcome getUserVpcSecurityGroup(const Model::GetUserVpcSecurityGroupRequest &request)const;
+			void getUserVpcSecurityGroupAsync(const Model::GetUserVpcSecurityGroupRequest& request, const GetUserVpcSecurityGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetUserVpcSecurityGroupOutcomeCallable getUserVpcSecurityGroupCallable(const Model::GetUserVpcSecurityGroupRequest& request) const;
+			GetUserVpcVSwitchOutcome getUserVpcVSwitch(const Model::GetUserVpcVSwitchRequest &request)const;
+			void getUserVpcVSwitchAsync(const Model::GetUserVpcVSwitchRequest& request, const GetUserVpcVSwitchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetUserVpcVSwitchOutcomeCallable getUserVpcVSwitchCallable(const Model::GetUserVpcVSwitchRequest& request) const;
+			GetUserVpcsOutcome getUserVpcs(const Model::GetUserVpcsRequest &request)const;
+			void getUserVpcsAsync(const Model::GetUserVpcsRequest& request, const GetUserVpcsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetUserVpcsOutcomeCallable getUserVpcsCallable(const Model::GetUserVpcsRequest& request) const;
+			ListEnvsOutcome listEnvs(const Model::ListEnvsRequest &request)const;
+			void listEnvsAsync(const Model::ListEnvsRequest& request, const ListEnvsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListEnvsOutcomeCallable listEnvsCallable(const Model::ListEnvsRequest& request) const;
+			ListJMeterReportsOutcome listJMeterReports(const Model::ListJMeterReportsRequest &request)const;
+			void listJMeterReportsAsync(const Model::ListJMeterReportsRequest& request, const ListJMeterReportsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListJMeterReportsOutcomeCallable listJMeterReportsCallable(const Model::ListJMeterReportsRequest& request) const;
+			ListOpenJMeterScenesOutcome listOpenJMeterScenes(const Model::ListOpenJMeterScenesRequest &request)const;
+			void listOpenJMeterScenesAsync(const Model::ListOpenJMeterScenesRequest& request, const ListOpenJMeterScenesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListOpenJMeterScenesOutcomeCallable listOpenJMeterScenesCallable(const Model::ListOpenJMeterScenesRequest& request) const;
+			ListPtsSceneOutcome listPtsScene(const Model::ListPtsSceneRequest &request)const;
+			void listPtsSceneAsync(const Model::ListPtsSceneRequest& request, const ListPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListPtsSceneOutcomeCallable listPtsSceneCallable(const Model::ListPtsSceneRequest& request) const;
+			ModifyPtsSceneOutcome modifyPtsScene(const Model::ModifyPtsSceneRequest &request)const;
+			void modifyPtsSceneAsync(const Model::ModifyPtsSceneRequest& request, const ModifyPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyPtsSceneOutcomeCallable modifyPtsSceneCallable(const Model::ModifyPtsSceneRequest& request) const;
+			RemoveEnvOutcome removeEnv(const Model::RemoveEnvRequest &request)const;
+			void removeEnvAsync(const Model::RemoveEnvRequest& request, const RemoveEnvAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveEnvOutcomeCallable removeEnvCallable(const Model::RemoveEnvRequest& request) const;
+			RemoveOpenJMeterSceneOutcome removeOpenJMeterScene(const Model::RemoveOpenJMeterSceneRequest &request)const;
+			void removeOpenJMeterSceneAsync(const Model::RemoveOpenJMeterSceneRequest& request, const RemoveOpenJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveOpenJMeterSceneOutcomeCallable removeOpenJMeterSceneCallable(const Model::RemoveOpenJMeterSceneRequest& request) const;
+			SaveEnvOutcome saveEnv(const Model::SaveEnvRequest &request)const;
+			void saveEnvAsync(const Model::SaveEnvRequest& request, const SaveEnvAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SaveEnvOutcomeCallable saveEnvCallable(const Model::SaveEnvRequest& request) const;
+			SaveOpenJMeterSceneOutcome saveOpenJMeterScene(const Model::SaveOpenJMeterSceneRequest &request)const;
+			void saveOpenJMeterSceneAsync(const Model::SaveOpenJMeterSceneRequest& request, const SaveOpenJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SaveOpenJMeterSceneOutcomeCallable saveOpenJMeterSceneCallable(const Model::SaveOpenJMeterSceneRequest& request) const;
+			SavePtsSceneOutcome savePtsScene(const Model::SavePtsSceneRequest &request)const;
+			void savePtsSceneAsync(const Model::SavePtsSceneRequest& request, const SavePtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SavePtsSceneOutcomeCallable savePtsSceneCallable(const Model::SavePtsSceneRequest& request) const;
+			StartDebugPtsSceneOutcome startDebugPtsScene(const Model::StartDebugPtsSceneRequest &request)const;
+			void startDebugPtsSceneAsync(const Model::StartDebugPtsSceneRequest& request, const StartDebugPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartDebugPtsSceneOutcomeCallable startDebugPtsSceneCallable(const Model::StartDebugPtsSceneRequest& request) const;
+			StartDebuggingJMeterSceneOutcome startDebuggingJMeterScene(const Model::StartDebuggingJMeterSceneRequest &request)const;
+			void startDebuggingJMeterSceneAsync(const Model::StartDebuggingJMeterSceneRequest& request, const StartDebuggingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartDebuggingJMeterSceneOutcomeCallable startDebuggingJMeterSceneCallable(const Model::StartDebuggingJMeterSceneRequest& request) const;
+			StartPtsSceneOutcome startPtsScene(const Model::StartPtsSceneRequest &request)const;
+			void startPtsSceneAsync(const Model::StartPtsSceneRequest& request, const StartPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartPtsSceneOutcomeCallable startPtsSceneCallable(const Model::StartPtsSceneRequest& request) const;
+			StartTestingJMeterSceneOutcome startTestingJMeterScene(const Model::StartTestingJMeterSceneRequest &request)const;
+			void startTestingJMeterSceneAsync(const Model::StartTestingJMeterSceneRequest& request, const StartTestingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartTestingJMeterSceneOutcomeCallable startTestingJMeterSceneCallable(const Model::StartTestingJMeterSceneRequest& request) const;
+			StopDebugPtsSceneOutcome stopDebugPtsScene(const Model::StopDebugPtsSceneRequest &request)const;
+			void stopDebugPtsSceneAsync(const Model::StopDebugPtsSceneRequest& request, const StopDebugPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopDebugPtsSceneOutcomeCallable stopDebugPtsSceneCallable(const Model::StopDebugPtsSceneRequest& request) const;
+			StopDebuggingJMeterSceneOutcome stopDebuggingJMeterScene(const Model::StopDebuggingJMeterSceneRequest &request)const;
+			void stopDebuggingJMeterSceneAsync(const Model::StopDebuggingJMeterSceneRequest& request, const StopDebuggingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopDebuggingJMeterSceneOutcomeCallable stopDebuggingJMeterSceneCallable(const Model::StopDebuggingJMeterSceneRequest& request) const;
+			StopPtsSceneOutcome stopPtsScene(const Model::StopPtsSceneRequest &request)const;
+			void stopPtsSceneAsync(const Model::StopPtsSceneRequest& request, const StopPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopPtsSceneOutcomeCallable stopPtsSceneCallable(const Model::StopPtsSceneRequest& request) const;
+			StopTestingJMeterSceneOutcome stopTestingJMeterScene(const Model::StopTestingJMeterSceneRequest &request)const;
+			void stopTestingJMeterSceneAsync(const Model::StopTestingJMeterSceneRequest& request, const StopTestingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopTestingJMeterSceneOutcomeCallable stopTestingJMeterSceneCallable(const Model::StopTestingJMeterSceneRequest& request) const;
+			UpdatePtsSceneBaseLineOutcome updatePtsSceneBaseLine(const Model::UpdatePtsSceneBaseLineRequest &request)const;
+			void updatePtsSceneBaseLineAsync(const Model::UpdatePtsSceneBaseLineRequest& request, const UpdatePtsSceneBaseLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdatePtsSceneBaseLineOutcomeCallable updatePtsSceneBaseLineCallable(const Model::UpdatePtsSceneBaseLineRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_PTS_PTSCLIENT_H_

pts/include/alibabacloud/pts/PTSExport.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_PTS_PTSEXPORT_H_
+#define ALIBABACLOUD_PTS_PTSEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_PTS_LIBRARY)
+#		define ALIBABACLOUD_PTS_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_PTS_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_PTS_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_PTS_PTSEXPORT_H_

pts/include/alibabacloud/pts/model/AdjustJMeterSceneSpeedRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_ADJUSTJMETERSCENESPEEDREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_ADJUSTJMETERSCENESPEEDREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT AdjustJMeterSceneSpeedRequest : public RpcServiceRequest {
+public:
+	AdjustJMeterSceneSpeedRequest();
+	~AdjustJMeterSceneSpeedRequest();
+	std::string getReportId() const;
+	void setReportId(const std::string &reportId);
+	int getSpeed() const;
+	void setSpeed(int speed);
+
+private:
+	std::string reportId_;
+	int speed_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_ADJUSTJMETERSCENESPEEDREQUEST_H_

pts/include/alibabacloud/pts/model/AdjustJMeterSceneSpeedResult.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_PTS_MODEL_ADJUSTJMETERSCENESPEEDRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_ADJUSTJMETERSCENESPEEDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT AdjustJMeterSceneSpeedResult : public ServiceResult
+			{
+			public:
+
+
+				AdjustJMeterSceneSpeedResult();
+				explicit AdjustJMeterSceneSpeedResult(const std::string &payload);
+				~AdjustJMeterSceneSpeedResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getReportId()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string reportId_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_ADJUSTJMETERSCENESPEEDRESULT_H_

pts/include/alibabacloud/pts/model/CreatePtsSceneBaseLineFromReportRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_CREATEPTSSCENEBASELINEFROMREPORTREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_CREATEPTSSCENEBASELINEFROMREPORTREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT CreatePtsSceneBaseLineFromReportRequest : public RpcServiceRequest {
+public:
+	CreatePtsSceneBaseLineFromReportRequest();
+	~CreatePtsSceneBaseLineFromReportRequest();
+	std::string getReportId() const;
+	void setReportId(const std::string &reportId);
+	std::string getSceneId() const;
+	void setSceneId(const std::string &sceneId);
+
+private:
+	std::string reportId_;
+	std::string sceneId_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_CREATEPTSSCENEBASELINEFROMREPORTREQUEST_H_

pts/include/alibabacloud/pts/model/CreatePtsSceneBaseLineFromReportResult.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_PTS_MODEL_CREATEPTSSCENEBASELINEFROMREPORTRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_CREATEPTSSCENEBASELINEFROMREPORTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT CreatePtsSceneBaseLineFromReportResult : public ServiceResult
+			{
+			public:
+
+
+				CreatePtsSceneBaseLineFromReportResult();
+				explicit CreatePtsSceneBaseLineFromReportResult(const std::string &payload);
+				~CreatePtsSceneBaseLineFromReportResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_CREATEPTSSCENEBASELINEFROMREPORTRESULT_H_

pts/include/alibabacloud/pts/model/CreatePtsSceneRequest.h

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

pts/include/alibabacloud/pts/model/CreatePtsSceneResult.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_PTS_MODEL_CREATEPTSSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_CREATEPTSSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT CreatePtsSceneResult : public ServiceResult
+			{
+			public:
+
+
+				CreatePtsSceneResult();
+				explicit CreatePtsSceneResult(const std::string &payload);
+				~CreatePtsSceneResult();
+				std::string getSceneId()const;
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string sceneId_;
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_CREATEPTSSCENERESULT_H_

pts/include/alibabacloud/pts/model/DeletePtsSceneBaseLineRequest.h

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

pts/include/alibabacloud/pts/model/DeletePtsSceneBaseLineResult.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_PTS_MODEL_DELETEPTSSCENEBASELINERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_DELETEPTSSCENEBASELINERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT DeletePtsSceneBaseLineResult : public ServiceResult
+			{
+			public:
+
+
+				DeletePtsSceneBaseLineResult();
+				explicit DeletePtsSceneBaseLineResult(const std::string &payload);
+				~DeletePtsSceneBaseLineResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_DELETEPTSSCENEBASELINERESULT_H_

pts/include/alibabacloud/pts/model/DeletePtsSceneRequest.h

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

pts/include/alibabacloud/pts/model/DeletePtsSceneResult.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_PTS_MODEL_DELETEPTSSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_DELETEPTSSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT DeletePtsSceneResult : public ServiceResult
+			{
+			public:
+
+
+				DeletePtsSceneResult();
+				explicit DeletePtsSceneResult(const std::string &payload);
+				~DeletePtsSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_DELETEPTSSCENERESULT_H_

pts/include/alibabacloud/pts/model/DeletePtsScenesRequest.h

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

pts/include/alibabacloud/pts/model/DeletePtsScenesResult.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_PTS_MODEL_DELETEPTSSCENESRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_DELETEPTSSCENESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT DeletePtsScenesResult : public ServiceResult
+			{
+			public:
+
+
+				DeletePtsScenesResult();
+				explicit DeletePtsScenesResult(const std::string &payload);
+				~DeletePtsScenesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_DELETEPTSSCENESRESULT_H_

pts/include/alibabacloud/pts/model/GetAllRegionsRequest.h

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

pts/include/alibabacloud/pts/model/GetAllRegionsResult.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_PTS_MODEL_GETALLREGIONSRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETALLREGIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetAllRegionsResult : public ServiceResult
+			{
+			public:
+
+
+				GetAllRegionsResult();
+				explicit GetAllRegionsResult(const std::string &payload);
+				~GetAllRegionsResult();
+				std::string getMessage()const;
+				std::string getAllRegions()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string allRegions_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETALLREGIONSRESULT_H_

pts/include/alibabacloud/pts/model/GetJMeterLogsRequest.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_PTS_MODEL_GETJMETERLOGSREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_GETJMETERLOGSREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT GetJMeterLogsRequest : public RpcServiceRequest {
+public:
+	GetJMeterLogsRequest();
+	~GetJMeterLogsRequest();
+	int getAgentIndex() const;
+	void setAgentIndex(int agentIndex);
+	std::string getReportId() const;
+	void setReportId(const std::string &reportId);
+	std::string getLevel() const;
+	void setLevel(const std::string &level);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getBeginTime() const;
+	void setBeginTime(long beginTime);
+	std::string getThread() const;
+	void setThread(const std::string &thread);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getKeyword() const;
+	void setKeyword(const std::string &keyword);
+
+private:
+	int agentIndex_;
+	std::string reportId_;
+	std::string level_;
+	long endTime_;
+	long beginTime_;
+	std::string thread_;
+	int pageNumber_;
+	int pageSize_;
+	std::string keyword_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_GETJMETERLOGSREQUEST_H_

pts/include/alibabacloud/pts/model/GetJMeterLogsResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_GETJMETERLOGSRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETJMETERLOGSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetJMeterLogsResult : public ServiceResult
+			{
+			public:
+
+
+				GetJMeterLogsResult();
+				explicit GetJMeterLogsResult(const std::string &payload);
+				~GetJMeterLogsResult();
+				long getTotalCount()const;
+				int getAgentCount()const;
+				std::string getMessage()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<std::string> getLogs()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				int agentCount_;
+				std::string message_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<std::string> logs_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETJMETERLOGSRESULT_H_

pts/include/alibabacloud/pts/model/GetJMeterSampleMetricsRequest.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_PTS_MODEL_GETJMETERSAMPLEMETRICSREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_GETJMETERSAMPLEMETRICSREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT GetJMeterSampleMetricsRequest : public RpcServiceRequest {
+public:
+	GetJMeterSampleMetricsRequest();
+	~GetJMeterSampleMetricsRequest();
+	std::string getReportId() const;
+	void setReportId(const std::string &reportId);
+	int getSamplerId() const;
+	void setSamplerId(int samplerId);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getBeginTime() const;
+	void setBeginTime(long beginTime);
+
+private:
+	std::string reportId_;
+	int samplerId_;
+	long endTime_;
+	long beginTime_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_GETJMETERSAMPLEMETRICSREQUEST_H_

pts/include/alibabacloud/pts/model/GetJMeterSampleMetricsResult.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_PTS_MODEL_GETJMETERSAMPLEMETRICSRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETJMETERSAMPLEMETRICSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetJMeterSampleMetricsResult : public ServiceResult
+			{
+			public:
+
+
+				GetJMeterSampleMetricsResult();
+				explicit GetJMeterSampleMetricsResult(const std::string &payload);
+				~GetJMeterSampleMetricsResult();
+				std::string getSamplerMap()const;
+				std::string getMessage()const;
+				std::vector<std::string> getSampleMetricList()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string samplerMap_;
+				std::string message_;
+				std::vector<std::string> sampleMetricList_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETJMETERSAMPLEMETRICSRESULT_H_

pts/include/alibabacloud/pts/model/GetJMeterSamplingLogsRequest.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_PTS_MODEL_GETJMETERSAMPLINGLOGSREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_GETJMETERSAMPLINGLOGSREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT GetJMeterSamplingLogsRequest : public RpcServiceRequest {
+public:
+	GetJMeterSamplingLogsRequest();
+	~GetJMeterSamplingLogsRequest();
+	std::string getResponseCode() const;
+	void setResponseCode(const std::string &responseCode);
+	long getAgentId() const;
+	void setAgentId(long agentId);
+	std::string getReportId() const;
+	void setReportId(const std::string &reportId);
+	int getMinRT() const;
+	void setMinRT(int minRT);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getBeginTime() const;
+	void setBeginTime(long beginTime);
+	std::string getThread() const;
+	void setThread(const std::string &thread);
+	int getMaxRT() const;
+	void setMaxRT(int maxRT);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	int getSamplerId() const;
+	void setSamplerId(int samplerId);
+	bool getSuccess() const;
+	void setSuccess(bool success);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getKeyword() const;
+	void setKeyword(const std::string &keyword);
+
+private:
+	std::string responseCode_;
+	long agentId_;
+	std::string reportId_;
+	int minRT_;
+	long endTime_;
+	long beginTime_;
+	std::string thread_;
+	int maxRT_;
+	int pageNumber_;
+	int samplerId_;
+	bool success_;
+	int pageSize_;
+	std::string keyword_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_GETJMETERSAMPLINGLOGSREQUEST_H_

pts/include/alibabacloud/pts/model/GetJMeterSamplingLogsResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_GETJMETERSAMPLINGLOGSRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETJMETERSAMPLINGLOGSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetJMeterSamplingLogsResult : public ServiceResult
+			{
+			public:
+
+
+				GetJMeterSamplingLogsResult();
+				explicit GetJMeterSamplingLogsResult(const std::string &payload);
+				~GetJMeterSamplingLogsResult();
+				long getTotalCount()const;
+				std::string getMessage()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				int getHttpStatusCode()const;
+				std::vector<std::string> getSampleResults()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::string message_;
+				int pageSize_;
+				int pageNumber_;
+				int httpStatusCode_;
+				std::vector<std::string> sampleResults_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETJMETERSAMPLINGLOGSRESULT_H_

pts/include/alibabacloud/pts/model/GetJMeterSceneRunningDataRequest.h

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

pts/include/alibabacloud/pts/model/GetJMeterSceneRunningDataResult.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_PTS_MODEL_GETJMETERSCENERUNNINGDATARESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETJMETERSCENERUNNINGDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetJMeterSceneRunningDataResult : public ServiceResult
+			{
+			public:
+				struct RunningData
+				{
+					std::string status;
+					std::vector<std::string> sampleStatList;
+					int holdFor;
+					bool hasReport;
+					int agentCount;
+					std::string stageName;
+					long startTimeTS;
+					long vum;
+					std::string sceneId;
+					std::string sceneName;
+					std::string allSampleStat;
+					int concurrency;
+					std::vector<std::string> agentIdList;
+					bool isDebugging;
+				};
+
+
+				GetJMeterSceneRunningDataResult();
+				explicit GetJMeterSceneRunningDataResult(const std::string &payload);
+				~GetJMeterSceneRunningDataResult();
+				RunningData getRunningData()const;
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getDocumentUrl()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				RunningData runningData_;
+				std::string message_;
+				int httpStatusCode_;
+				std::string documentUrl_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETJMETERSCENERUNNINGDATARESULT_H_

pts/include/alibabacloud/pts/model/GetOpenJMeterSceneRequest.h

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

pts/include/alibabacloud/pts/model/GetOpenJMeterSceneResult.h

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_PTS_MODEL_GETOPENJMETERSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETOPENJMETERSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetOpenJMeterSceneResult : public ServiceResult
+			{
+			public:
+				struct Scene
+				{
+					struct BaseInfo
+					{
+						std::string modifyName;
+						std::string resource;
+						std::string createName;
+						std::string principal;
+						std::string operateType;
+						std::string remark;
+					};
+					struct DnsCacheConfig
+					{
+						bool clearCacheEachIteration;
+						std::vector<std::string> dnsServers;
+						std::string hostTable;
+					};
+					struct FileListItem
+					{
+						std::string fileType;
+						std::string fileName;
+						bool splitCsv;
+						long id;
+						std::string fileOssAddress;
+						std::string md5;
+						long fileSize;
+					};
+					int steps;
+					int maxRps;
+					int agentCount;
+					std::vector<FileListItem> fileList;
+					int startRps;
+					BaseInfo baseInfo;
+					DnsCacheConfig dnsCacheConfig;
+					std::string securityGroupId;
+					std::string vSwitchId;
+					std::string mode;
+					int duration;
+					bool isVpcTest;
+					int startConcurrency;
+					std::string sceneId;
+					std::string environmentId;
+					std::string sceneName;
+					std::string vpcId;
+					int concurrency;
+					std::string testFile;
+					std::string syncTimerType;
+					int rampUp;
+					std::string pool;
+					std::string regionId;
+					std::string constantThroughputTimerType;
+				};
+
+
+				GetOpenJMeterSceneResult();
+				explicit GetOpenJMeterSceneResult(const std::string &payload);
+				~GetOpenJMeterSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Scene getScene()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Scene scene_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETOPENJMETERSCENERESULT_H_

pts/include/alibabacloud/pts/model/GetPtsReportDetailsRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_GETPTSREPORTDETAILSREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_GETPTSREPORTDETAILSREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT GetPtsReportDetailsRequest : public RpcServiceRequest {
+public:
+	GetPtsReportDetailsRequest();
+	~GetPtsReportDetailsRequest();
+	std::string getSceneId() const;
+	void setSceneId(const std::string &sceneId);
+	std::string getPlanId() const;
+	void setPlanId(const std::string &planId);
+
+private:
+	std::string sceneId_;
+	std::string planId_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_GETPTSREPORTDETAILSREQUEST_H_

pts/include/alibabacloud/pts/model/GetPtsReportDetailsResult.h

@@ -0,0 +1,215 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_PTS_MODEL_GETPTSREPORTDETAILSRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETPTSREPORTDETAILSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetPtsReportDetailsResult : public ServiceResult
+			{
+			public:
+				struct ReportOverView
+				{
+					std::string reportName;
+					int agentCount;
+					std::string endTime;
+					std::string startTime;
+					std::string reportId;
+					long vum;
+				};
+				struct SceneMetrics
+				{
+					long allCount;
+					float successRateBiz;
+					float seg99Rt;
+					long failCountBiz;
+					float successRateReq;
+					float seg90Rt;
+					long failCountReq;
+					float avgTps;
+					float avgRt;
+				};
+				struct SceneSnapShot
+				{
+					struct LoadConfig
+					{
+						struct Configuration
+						{
+							int allRpsBegin;
+							int allRpsLimit;
+							int allConcurrencyBegin;
+							int allConcurrencyLimit;
+						};
+						struct ApiLoadConfig
+						{
+							int rpsLimit;
+							int rpsBegin;
+						};
+						struct RelationLoadConfig
+						{
+							int concurrencyLimit;
+							int concurrencyBegin;
+						};
+						int agentCount;
+						Configuration configuration;
+						std::string testMode;
+						int maxRunningTime;
+						std::vector<ApiLoadConfig> apiLoadConfigList;
+						std::vector<RelationLoadConfig> relationLoadConfigList;
+					};
+					struct AdvanceSetting
+					{
+						struct DomainBinding
+						{
+							std::string domain;
+							std::vector<std::string> ips;
+						};
+						int logRate;
+						std::vector<DomainBinding> domainBindingList;
+						int connectionTimeoutInSecond;
+						std::string successCode;
+					};
+					struct FileParameter
+					{
+						std::string fileName;
+						std::string fileOssAddress;
+					};
+					struct Relation
+					{
+						struct FileParameterExplain
+						{
+							bool baseFile;
+							bool cycleOnce;
+							std::string fileParamName;
+							std::string fileName;
+						};
+						struct Api
+						{
+							struct Body
+							{
+								std::string contentType;
+								std::string bodyValue;
+							};
+							struct CheckPoint
+							{
+								std::string expectValue;
+								std::string checkType;
+								std::string _operator;
+								std::string checkPoint;
+							};
+							struct Header
+							{
+								std::string headerValue;
+								std::string headerName;
+							};
+							struct Export
+							{
+								std::string exportType;
+								std::string exportName;
+								std::string exportValue;
+								std::string count;
+							};
+							std::vector<Api::Export> exportList;
+							std::string apiName;
+							std::vector<Api::Header> headerList;
+							int redirectCountLimit;
+							std::vector<Api::CheckPoint> checkPointList;
+							std::string method;
+							int timeoutInSecond;
+							Body body;
+							std::string apiId;
+							std::string url;
+						};
+						std::vector<Relation::Api> apiList;
+						std::string relationId;
+						std::string relationName;
+						std::vector<Relation::FileParameterExplain> fileParameterExplainList;
+					};
+					struct GlobalParameter
+					{
+						std::string paramValue;
+						std::string paramName;
+					};
+					std::string status;
+					std::string sceneId;
+					AdvanceSetting advanceSetting;
+					std::vector<Relation> relationList;
+					std::string modifiedTime;
+					std::string sceneName;
+					LoadConfig loadConfig;
+					std::string createTime;
+					std::vector<GlobalParameter> globalParameterList;
+					std::vector<FileParameter> fileParameterList;
+				};
+				struct ApiMetrics
+				{
+					long failCountBiz;
+					std::string apiName;
+					float seg90Rt;
+					long failCountReq;
+					float maxRt;
+					float seg50Rt;
+					long allCount;
+					float seg99Rt;
+					float successRateBiz;
+					float seg75Rt;
+					float successRateReq;
+					float minRt;
+					float avgTps;
+					float avgRt;
+				};
+
+
+				GetPtsReportDetailsResult();
+				explicit GetPtsReportDetailsResult(const std::string &payload);
+				~GetPtsReportDetailsResult();
+				ReportOverView getReportOverView()const;
+				SceneMetrics getSceneMetrics()const;
+				std::string getMessage()const;
+				std::vector<ApiMetrics> getApiMetricsList()const;
+				int getHttpStatusCode()const;
+				SceneSnapShot getSceneSnapShot()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ReportOverView reportOverView_;
+				SceneMetrics sceneMetrics_;
+				std::string message_;
+				std::vector<ApiMetrics> apiMetricsList_;
+				int httpStatusCode_;
+				SceneSnapShot sceneSnapShot_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETPTSREPORTDETAILSRESULT_H_

pts/include/alibabacloud/pts/model/GetPtsReportsBySceneIdRequest.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_PTS_MODEL_GETPTSREPORTSBYSCENEIDREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_GETPTSREPORTSBYSCENEIDREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT GetPtsReportsBySceneIdRequest : public RpcServiceRequest {
+public:
+	GetPtsReportsBySceneIdRequest();
+	~GetPtsReportsBySceneIdRequest();
+	std::string getSceneId() const;
+	void setSceneId(const std::string &sceneId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+
+private:
+	std::string sceneId_;
+	int pageSize_;
+	int pageNumber_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_GETPTSREPORTSBYSCENEIDREQUEST_H_

pts/include/alibabacloud/pts/model/GetPtsReportsBySceneIdResult.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_GETPTSREPORTSBYSCENEIDRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETPTSREPORTSBYSCENEIDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetPtsReportsBySceneIdResult : public ServiceResult
+			{
+			public:
+				struct ReportOverView
+				{
+					std::string reportName;
+					int agentCount;
+					std::string endTime;
+					std::string startTime;
+					std::string reportId;
+					long vum;
+				};
+
+
+				GetPtsReportsBySceneIdResult();
+				explicit GetPtsReportsBySceneIdResult(const std::string &payload);
+				~GetPtsReportsBySceneIdResult();
+				std::string getMessage()const;
+				std::vector<ReportOverView> getReportOverViewList()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::vector<ReportOverView> reportOverViewList_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETPTSREPORTSBYSCENEIDRESULT_H_

pts/include/alibabacloud/pts/model/GetPtsSceneBaseLineRequest.h

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

pts/include/alibabacloud/pts/model/GetPtsSceneBaseLineResult.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_GETPTSSCENEBASELINERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETPTSSCENEBASELINERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetPtsSceneBaseLineResult : public ServiceResult
+			{
+			public:
+				struct Baseline
+				{
+					struct SceneBaseline
+					{
+						float successRateBiz;
+						float seg99Rt;
+						long failCountBiz;
+						float successRateReq;
+						float seg90Rt;
+						long failCountReq;
+						float avgTps;
+						float avgRt;
+					};
+					struct ChainBaselineData
+					{
+						float seg99Rt;
+						float successRateBiz;
+						long failCountBiz;
+						float successRateReq;
+						int minRt;
+						float seg90Rt;
+						long failCountReq;
+						long id;
+						float avgTps;
+						int maxRt;
+						float avgRt;
+						std::string name;
+					};
+					SceneBaseline sceneBaseline;
+					std::vector<ChainBaselineData> apiBaselines;
+					std::string name;
+				};
+
+
+				GetPtsSceneBaseLineResult();
+				explicit GetPtsSceneBaseLineResult(const std::string &payload);
+				~GetPtsSceneBaseLineResult();
+				std::string getSceneId()const;
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Baseline getBaseline()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string sceneId_;
+				std::string message_;
+				int httpStatusCode_;
+				Baseline baseline_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETPTSSCENEBASELINERESULT_H_

pts/include/alibabacloud/pts/model/GetPtsSceneRequest.h

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

pts/include/alibabacloud/pts/model/GetPtsSceneResult.h

@@ -0,0 +1,184 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_PTS_MODEL_GETPTSSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETPTSSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetPtsSceneResult : public ServiceResult
+			{
+			public:
+				struct Scene
+				{
+					struct LoadConfig
+					{
+						struct Configuration
+						{
+							int allRpsBegin;
+							int allRpsLimit;
+							int allConcurrencyBegin;
+							int allConcurrencyLimit;
+						};
+						struct VpcLoadConfig
+						{
+							std::string vpcId;
+							std::string vSwitchId;
+							std::string securityGroupId;
+							std::string regionId;
+						};
+						struct ApiLoadConfig
+						{
+							int rpsLimit;
+							int rpsBegin;
+							std::string apiId;
+						};
+						struct RelationLoadConfig
+						{
+							int concurrencyLimit;
+							std::string relationId;
+							int concurrencyBegin;
+						};
+						bool autoStep;
+						int agentCount;
+						Configuration configuration;
+						int increment;
+						std::string testMode;
+						int maxRunningTime;
+						int keepTime;
+						std::vector<ApiLoadConfig> apiLoadConfigList;
+						VpcLoadConfig vpcLoadConfig;
+						std::vector<RelationLoadConfig> relationLoadConfigList;
+					};
+					struct AdvanceSetting
+					{
+						struct DomainBinding
+						{
+							std::string domain;
+							std::vector<std::string> ips;
+						};
+						int logRate;
+						std::vector<DomainBinding> domainBindingList;
+						int connectionTimeoutInSecond;
+						std::string successCode;
+					};
+					struct FileParameter
+					{
+						std::string fileName;
+						std::string fileOssAddress;
+					};
+					struct Relation
+					{
+						struct FileParameterExplain
+						{
+							bool baseFile;
+							bool cycleOnce;
+							std::string fileParamName;
+							std::string fileName;
+						};
+						struct Api
+						{
+							struct Body
+							{
+								std::string contentType;
+								std::string bodyValue;
+							};
+							struct CheckPoint
+							{
+								std::string expectValue;
+								std::string checkType;
+								std::string _operator;
+								std::string checkPoint;
+							};
+							struct Header
+							{
+								std::string headerValue;
+								std::string headerName;
+							};
+							struct Export
+							{
+								std::string exportType;
+								std::string exportName;
+								std::string exportValue;
+								std::string count;
+							};
+							std::vector<Api::Export> exportList;
+							std::string apiName;
+							std::vector<Api::Header> headerList;
+							int redirectCountLimit;
+							std::vector<Api::CheckPoint> checkPointList;
+							std::string method;
+							int timeoutInSecond;
+							Body body;
+							std::string apiId;
+							std::string url;
+						};
+						std::vector<Relation::Api> apiList;
+						std::string relationId;
+						std::string relationName;
+						std::vector<Relation::FileParameterExplain> fileParameterExplainList;
+					};
+					struct GlobalParameter
+					{
+						std::string paramValue;
+						std::string paramName;
+					};
+					std::string status;
+					std::string sceneId;
+					AdvanceSetting advanceSetting;
+					std::vector<Relation> relationList;
+					std::string modifiedTime;
+					std::string sceneName;
+					LoadConfig loadConfig;
+					std::string createTime;
+					std::vector<GlobalParameter> globalParameterList;
+					std::vector<FileParameter> fileParameterList;
+				};
+
+
+				GetPtsSceneResult();
+				explicit GetPtsSceneResult(const std::string &payload);
+				~GetPtsSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Scene getScene()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Scene scene_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETPTSSCENERESULT_H_

pts/include/alibabacloud/pts/model/GetPtsSceneRunningDataRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_GETPTSSCENERUNNINGDATAREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_GETPTSSCENERUNNINGDATAREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT GetPtsSceneRunningDataRequest : public RpcServiceRequest {
+public:
+	GetPtsSceneRunningDataRequest();
+	~GetPtsSceneRunningDataRequest();
+	std::string getSceneId() const;
+	void setSceneId(const std::string &sceneId);
+	std::string getPlanId() const;
+	void setPlanId(const std::string &planId);
+
+private:
+	std::string sceneId_;
+	std::string planId_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_GETPTSSCENERUNNINGDATAREQUEST_H_

pts/include/alibabacloud/pts/model/GetPtsSceneRunningDataResult.h

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_PTS_MODEL_GETPTSSCENERUNNINGDATARESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETPTSSCENERUNNINGDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetPtsSceneRunningDataResult : public ServiceResult
+			{
+			public:
+				struct Location
+				{
+					std::string isp;
+					std::string region;
+					int count;
+					std::string province;
+				};
+				struct ChainMonitorData
+				{
+					struct CheckPointResult
+					{
+						long failedBusinessCount;
+						float failedBusinessQps;
+						float succeedBusinessQps;
+						long succeedBusinessCount;
+					};
+					CheckPointResult checkPointResult;
+					std::string apiName;
+					long timePoint;
+					float qps2XX;
+					int maxRt;
+					int configQps;
+					long count2XX;
+					int averageRt;
+					float concurrency;
+					float failedQps;
+					float realQps;
+					long nodeId;
+					long failedCount;
+					int minRt;
+					std::string apiId;
+				};
+
+
+				GetPtsSceneRunningDataResult();
+				explicit GetPtsSceneRunningDataResult(const std::string &payload);
+				~GetPtsSceneRunningDataResult();
+				int getStatus()const;
+				long getTotalRequestCount()const;
+				bool getHasReport()const;
+				int getConcurrencyLimit()const;
+				std::string getMessage()const;
+				std::vector<Location> getAgentLocation()const;
+				long getBeginTime()const;
+				long getSeg90Rt()const;
+				std::string getResponseBps()const;
+				int getTotalAgents()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+				long getVum()const;
+				std::vector<ChainMonitorData> getChainMonitorDataList()const;
+				long getAverageRt()const;
+				std::string getRequestBps()const;
+				long getFailedBusinessCount()const;
+				int getConcurrency()const;
+				int getHttpStatusCode()const;
+				int getTotalRealQps()const;
+				long getFailedRequestCount()const;
+				int getTpsLimit()const;
+				int getAliveAgents()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int status_;
+				long totalRequestCount_;
+				bool hasReport_;
+				int concurrencyLimit_;
+				std::string message_;
+				std::vector<Location> agentLocation_;
+				long beginTime_;
+				long seg90Rt_;
+				std::string responseBps_;
+				int totalAgents_;
+				std::string code_;
+				bool success_;
+				long vum_;
+				std::vector<ChainMonitorData> chainMonitorDataList_;
+				long averageRt_;
+				std::string requestBps_;
+				long failedBusinessCount_;
+				int concurrency_;
+				int httpStatusCode_;
+				int totalRealQps_;
+				long failedRequestCount_;
+				int tpsLimit_;
+				int aliveAgents_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETPTSSCENERUNNINGDATARESULT_H_

pts/include/alibabacloud/pts/model/GetPtsSceneRunningStatusRequest.h

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

pts/include/alibabacloud/pts/model/GetPtsSceneRunningStatusResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_GETPTSSCENERUNNINGSTATUSRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETPTSSCENERUNNINGSTATUSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetPtsSceneRunningStatusResult : public ServiceResult
+			{
+			public:
+
+
+				GetPtsSceneRunningStatusResult();
+				explicit GetPtsSceneRunningStatusResult(const std::string &payload);
+				~GetPtsSceneRunningStatusResult();
+				std::string getStatus()const;
+				std::string getModifiedTime()const;
+				std::string getMessage()const;
+				std::string getSceneName()const;
+				std::string getCreateTime()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string modifiedTime_;
+				std::string message_;
+				std::string sceneName_;
+				std::string createTime_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETPTSSCENERUNNINGSTATUSRESULT_H_

pts/include/alibabacloud/pts/model/GetUserVpcSecurityGroupRequest.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_PTS_MODEL_GETUSERVPCSECURITYGROUPREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_GETUSERVPCSECURITYGROUPREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT GetUserVpcSecurityGroupRequest : public RpcServiceRequest {
+public:
+	GetUserVpcSecurityGroupRequest();
+	~GetUserVpcSecurityGroupRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+
+private:
+	std::string regionId_;
+	std::string vpcId_;
+	int pageSize_;
+	int pageNumber_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_GETUSERVPCSECURITYGROUPREQUEST_H_

pts/include/alibabacloud/pts/model/GetUserVpcSecurityGroupResult.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_PTS_MODEL_GETUSERVPCSECURITYGROUPRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETUSERVPCSECURITYGROUPRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetUserVpcSecurityGroupResult : public ServiceResult
+			{
+			public:
+				struct SecurityGroup
+				{
+					std::string description;
+					std::string vpcId;
+					std::string securityGroupName;
+					std::string securityGroupId;
+				};
+
+
+				GetUserVpcSecurityGroupResult();
+				explicit GetUserVpcSecurityGroupResult(const std::string &payload);
+				~GetUserVpcSecurityGroupResult();
+				std::vector<SecurityGroup> getSecurityGroupList()const;
+				int getSecurityGroupCount()const;
+				std::string getMessage()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SecurityGroup> securityGroupList_;
+				int securityGroupCount_;
+				std::string message_;
+				int pageSize_;
+				int pageNumber_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETUSERVPCSECURITYGROUPRESULT_H_

pts/include/alibabacloud/pts/model/GetUserVpcVSwitchRequest.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_PTS_MODEL_GETUSERVPCVSWITCHREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_GETUSERVPCVSWITCHREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT GetUserVpcVSwitchRequest : public RpcServiceRequest {
+public:
+	GetUserVpcVSwitchRequest();
+	~GetUserVpcVSwitchRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+
+private:
+	std::string regionId_;
+	std::string vpcId_;
+	int pageSize_;
+	int pageNumber_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_GETUSERVPCVSWITCHREQUEST_H_

pts/include/alibabacloud/pts/model/GetUserVpcVSwitchResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_GETUSERVPCVSWITCHRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETUSERVPCVSWITCHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetUserVpcVSwitchResult : public ServiceResult
+			{
+			public:
+				struct VSwitch
+				{
+					std::string vpcId;
+					long availableIpAddressCount;
+					std::string vSwitchId;
+					std::string vSwitchName;
+					int maxAgentCount;
+				};
+
+
+				GetUserVpcVSwitchResult();
+				explicit GetUserVpcVSwitchResult(const std::string &payload);
+				~GetUserVpcVSwitchResult();
+				int getVSwitchCount()const;
+				std::string getMessage()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<VSwitch> getVSwitchList()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int vSwitchCount_;
+				std::string message_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<VSwitch> vSwitchList_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETUSERVPCVSWITCHRESULT_H_

pts/include/alibabacloud/pts/model/GetUserVpcsRequest.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_PTS_MODEL_GETUSERVPCSREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_GETUSERVPCSREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT GetUserVpcsRequest : public RpcServiceRequest {
+public:
+	GetUserVpcsRequest();
+	~GetUserVpcsRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+
+private:
+	std::string regionId_;
+	std::string vpcId_;
+	int pageSize_;
+	int pageNumber_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_GETUSERVPCSREQUEST_H_

pts/include/alibabacloud/pts/model/GetUserVpcsResult.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_GETUSERVPCSRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_GETUSERVPCSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT GetUserVpcsResult : public ServiceResult
+			{
+			public:
+				struct Vpc
+				{
+					std::string description;
+					std::string vpcId;
+					std::string resourceGroupId;
+					std::vector<std::string> vSwitchIds;
+					std::string cidrBlock;
+					std::vector<std::string> routerTableIds;
+					std::string vpcName;
+					std::string regionId;
+				};
+
+
+				GetUserVpcsResult();
+				explicit GetUserVpcsResult(const std::string &payload);
+				~GetUserVpcsResult();
+				std::vector<Vpc> getVpcs()const;
+				long getTotalCount()const;
+				std::string getMessage()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Vpc> vpcs_;
+				long totalCount_;
+				std::string message_;
+				int pageSize_;
+				int pageNumber_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_GETUSERVPCSRESULT_H_

pts/include/alibabacloud/pts/model/ListEnvsRequest.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_PTS_MODEL_LISTENVSREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_LISTENVSREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT ListEnvsRequest : public RpcServiceRequest {
+public:
+	ListEnvsRequest();
+	~ListEnvsRequest();
+	std::string getEnvName() const;
+	void setEnvName(const std::string &envName);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getEnvId() const;
+	void setEnvId(const std::string &envId);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+
+private:
+	std::string envName_;
+	int pageSize_;
+	std::string envId_;
+	int pageNumber_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_LISTENVSREQUEST_H_

pts/include/alibabacloud/pts/model/ListEnvsResult.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_PTS_MODEL_LISTENVSRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_LISTENVSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT ListEnvsResult : public ServiceResult
+			{
+			public:
+				struct Env
+				{
+					struct File
+					{
+						std::string fileName;
+						long fileId;
+						long fileSize;
+						std::string md5;
+						std::string fileOssAddress;
+					};
+					struct PropertiesItem
+					{
+						std::string description;
+						std::string value;
+						std::string name;
+					};
+					std::string envVersion;
+					std::vector<std::string> runningScenes;
+					long modifiedTime;
+					long createTime;
+					std::string envId;
+					std::vector<std::string> relatedScenes;
+					long usedCapacity;
+					std::vector<Env::File> files;
+					std::vector<Env::PropertiesItem> properties;
+					std::string envName;
+				};
+
+
+				ListEnvsResult();
+				explicit ListEnvsResult(const std::string &payload);
+				~ListEnvsResult();
+				long getTotalCount()const;
+				std::string getMessage()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<Env> getEnvs()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::string message_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<Env> envs_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_LISTENVSRESULT_H_

pts/include/alibabacloud/pts/model/ListJMeterReportsRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_LISTJMETERREPORTSREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_LISTJMETERREPORTSREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT ListJMeterReportsRequest : public RpcServiceRequest {
+public:
+	ListJMeterReportsRequest();
+	~ListJMeterReportsRequest();
+	std::string getReportId() const;
+	void setReportId(const std::string &reportId);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getBeginTime() const;
+	void setBeginTime(long beginTime);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getSceneId() const;
+	void setSceneId(const std::string &sceneId);
+	std::string getKeyword() const;
+	void setKeyword(const std::string &keyword);
+
+private:
+	std::string reportId_;
+	long endTime_;
+	long beginTime_;
+	int pageNumber_;
+	int pageSize_;
+	std::string sceneId_;
+	std::string keyword_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_LISTJMETERREPORTSREQUEST_H_

pts/include/alibabacloud/pts/model/ListJMeterReportsResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_LISTJMETERREPORTSRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_LISTJMETERREPORTSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT ListJMeterReportsResult : public ServiceResult
+			{
+			public:
+				struct JMeterReportView
+				{
+					std::string reportName;
+					long actualStartTime;
+					std::string reportId;
+					std::string duration;
+					long vum;
+				};
+
+
+				ListJMeterReportsResult();
+				explicit ListJMeterReportsResult(const std::string &payload);
+				~ListJMeterReportsResult();
+				long getTotalCount()const;
+				std::string getMessage()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				int getHttpStatusCode()const;
+				std::vector<JMeterReportView> getReports()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::string message_;
+				int pageSize_;
+				int pageNumber_;
+				int httpStatusCode_;
+				std::vector<JMeterReportView> reports_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_LISTJMETERREPORTSRESULT_H_

pts/include/alibabacloud/pts/model/ListOpenJMeterScenesRequest.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_PTS_MODEL_LISTOPENJMETERSCENESREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_LISTOPENJMETERSCENESREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT ListOpenJMeterScenesRequest : public RpcServiceRequest {
+public:
+	ListOpenJMeterScenesRequest();
+	~ListOpenJMeterScenesRequest();
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getSceneId() const;
+	void setSceneId(const std::string &sceneId);
+	std::string getSceneName() const;
+	void setSceneName(const std::string &sceneName);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+
+private:
+	int pageSize_;
+	std::string sceneId_;
+	std::string sceneName_;
+	int pageNumber_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_LISTOPENJMETERSCENESREQUEST_H_

pts/include/alibabacloud/pts/model/ListOpenJMeterScenesResult.h

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_LISTOPENJMETERSCENESRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_LISTOPENJMETERSCENESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT ListOpenJMeterScenesResult : public ServiceResult
+			{
+			public:
+				struct JMeterSceneItem
+				{
+					std::string sceneId;
+					std::string sceneName;
+					std::string durationStr;
+				};
+
+
+				ListOpenJMeterScenesResult();
+				explicit ListOpenJMeterScenesResult(const std::string &payload);
+				~ListOpenJMeterScenesResult();
+				long getTotalCount()const;
+				std::string getMessage()const;
+				int getPageSize()const;
+				std::vector<JMeterSceneItem> getJMeterScene()const;
+				int getPageNumber()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				long totalCount_;
+				std::string message_;
+				int pageSize_;
+				std::vector<JMeterSceneItem> jMeterScene_;
+				int pageNumber_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_LISTOPENJMETERSCENESRESULT_H_

pts/include/alibabacloud/pts/model/ListPtsSceneRequest.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_PTS_MODEL_LISTPTSSCENEREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_LISTPTSSCENEREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT ListPtsSceneRequest : public RpcServiceRequest {
+public:
+	ListPtsSceneRequest();
+	~ListPtsSceneRequest();
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getKeyWord() const;
+	void setKeyWord(const std::string &keyWord);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+
+private:
+	int pageSize_;
+	std::string keyWord_;
+	int pageNumber_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_LISTPTSSCENEREQUEST_H_

pts/include/alibabacloud/pts/model/ListPtsSceneResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_LISTPTSSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_LISTPTSSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT ListPtsSceneResult : public ServiceResult
+			{
+			public:
+				struct SceneView
+				{
+					std::string sceneId;
+					std::string sceneName;
+					std::string createTime;
+				};
+
+
+				ListPtsSceneResult();
+				explicit ListPtsSceneResult(const std::string &payload);
+				~ListPtsSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<SceneView> getSceneViewList()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<SceneView> sceneViewList_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_LISTPTSSCENERESULT_H_

pts/include/alibabacloud/pts/model/ModifyPtsSceneRequest.h

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

pts/include/alibabacloud/pts/model/ModifyPtsSceneResult.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_PTS_MODEL_MODIFYPTSSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_MODIFYPTSSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT ModifyPtsSceneResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyPtsSceneResult();
+				explicit ModifyPtsSceneResult(const std::string &payload);
+				~ModifyPtsSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_MODIFYPTSSCENERESULT_H_

pts/include/alibabacloud/pts/model/RemoveEnvRequest.h

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

pts/include/alibabacloud/pts/model/RemoveEnvResult.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_PTS_MODEL_REMOVEENVRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_REMOVEENVRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT RemoveEnvResult : public ServiceResult
+			{
+			public:
+
+
+				RemoveEnvResult();
+				explicit RemoveEnvResult(const std::string &payload);
+				~RemoveEnvResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_REMOVEENVRESULT_H_

pts/include/alibabacloud/pts/model/RemoveOpenJMeterSceneRequest.h

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

pts/include/alibabacloud/pts/model/RemoveOpenJMeterSceneResult.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_PTS_MODEL_REMOVEOPENJMETERSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_REMOVEOPENJMETERSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT RemoveOpenJMeterSceneResult : public ServiceResult
+			{
+			public:
+
+
+				RemoveOpenJMeterSceneResult();
+				explicit RemoveOpenJMeterSceneResult(const std::string &payload);
+				~RemoveOpenJMeterSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_REMOVEOPENJMETERSCENERESULT_H_

pts/include/alibabacloud/pts/model/SaveEnvRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_SAVEENVREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_SAVEENVREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT SaveEnvRequest : public RpcServiceRequest {
+public:
+	struct Env {
+		std::string envName;
+		struct FilesItem {
+			std::string fileName;
+			std::string fileOssAddress;
+		};
+		FilesItem filesItem;
+		std::vector<FilesItem> files;
+		std::string jmeterPluginLabel;
+		std::string envId;
+		struct PropertiesItem {
+			std::string name;
+			std::string description;
+			std::string value;
+		};
+		PropertiesItem propertiesItem;
+		std::vector<PropertiesItem> properties;
+	};
+	SaveEnvRequest();
+	~SaveEnvRequest();
+	Env getEnv() const;
+	void setEnv(const Env &env);
+
+private:
+	Env env_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_SAVEENVREQUEST_H_

pts/include/alibabacloud/pts/model/SaveEnvResult.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_PTS_MODEL_SAVEENVRESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_SAVEENVRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT SaveEnvResult : public ServiceResult
+			{
+			public:
+
+
+				SaveEnvResult();
+				explicit SaveEnvResult(const std::string &payload);
+				~SaveEnvResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getEnvId()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string envId_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_SAVEENVRESULT_H_

pts/include/alibabacloud/pts/model/SaveOpenJMeterSceneRequest.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_PTS_MODEL_SAVEOPENJMETERSCENEREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_SAVEOPENJMETERSCENEREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT SaveOpenJMeterSceneRequest : public RpcServiceRequest {
+public:
+	struct OpenJMeterScene {
+		int startConcurrency;
+		std::string testFile;
+		std::string constantThroughputTimerType;
+		std::string sceneName;
+		std::string securityGroupId;
+		struct FileListItem {
+			std::string fileName;
+			bool splitCsv;
+			long fileSize;
+			std::string fileOssAddress;
+			std::string md5;
+			long fileId;
+			std::string tags;
+		};
+		FileListItem fileListItem;
+		std::vector<FileListItem> fileList;
+		int steps;
+		int startRps;
+		int concurrency;
+		int duration;
+		int agentCount;
+		std::string vSwitchId;
+		std::string mode;
+		bool isVpcTest;
+		std::string environmentId;
+		std::string regionId;
+		std::string vpcId;
+		std::string sceneId;
+		std::string jmeterPluginLabel;
+		struct DnsCacheConfig {
+			bool clearCacheEachIteration;
+			std::string string;
+			std::vector<std::string> dnsServers;
+			std::map<std::string, std::string> hostTable;
+		};
+		DnsCacheConfig dnsCacheConfig;
+		struct JMeterPropertiesItem {
+			std::string name;
+			std::string value;
+		};
+		JMeterPropertiesItem jMeterPropertiesItem;
+		std::vector<JMeterPropertiesItem> jMeterProperties;
+		std::string syncTimerType;
+		int maxRps;
+		int rampUp;
+	};
+	SaveOpenJMeterSceneRequest();
+	~SaveOpenJMeterSceneRequest();
+	OpenJMeterScene getOpenJMeterScene() const;
+	void setOpenJMeterScene(const OpenJMeterScene &openJMeterScene);
+
+private:
+	OpenJMeterScene openJMeterScene_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_SAVEOPENJMETERSCENEREQUEST_H_

pts/include/alibabacloud/pts/model/SaveOpenJMeterSceneResult.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_PTS_MODEL_SAVEOPENJMETERSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_SAVEOPENJMETERSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT SaveOpenJMeterSceneResult : public ServiceResult
+			{
+			public:
+
+
+				SaveOpenJMeterSceneResult();
+				explicit SaveOpenJMeterSceneResult(const std::string &payload);
+				~SaveOpenJMeterSceneResult();
+				std::string getSceneId()const;
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string sceneId_;
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_SAVEOPENJMETERSCENERESULT_H_

pts/include/alibabacloud/pts/model/SavePtsSceneRequest.h

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

pts/include/alibabacloud/pts/model/SavePtsSceneResult.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_PTS_MODEL_SAVEPTSSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_SAVEPTSSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT SavePtsSceneResult : public ServiceResult
+			{
+			public:
+
+
+				SavePtsSceneResult();
+				explicit SavePtsSceneResult(const std::string &payload);
+				~SavePtsSceneResult();
+				std::string getSceneId()const;
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string sceneId_;
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_SAVEPTSSCENERESULT_H_

pts/include/alibabacloud/pts/model/StartDebugPtsSceneRequest.h

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

pts/include/alibabacloud/pts/model/StartDebugPtsSceneResult.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_PTS_MODEL_STARTDEBUGPTSSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_STARTDEBUGPTSSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT StartDebugPtsSceneResult : public ServiceResult
+			{
+			public:
+
+
+				StartDebugPtsSceneResult();
+				explicit StartDebugPtsSceneResult(const std::string &payload);
+				~StartDebugPtsSceneResult();
+				std::string getMessage()const;
+				std::string getPlanId()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string planId_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_STARTDEBUGPTSSCENERESULT_H_

pts/include/alibabacloud/pts/model/StartDebuggingJMeterSceneRequest.h

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

pts/include/alibabacloud/pts/model/StartDebuggingJMeterSceneResult.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_PTS_MODEL_STARTDEBUGGINGJMETERSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_STARTDEBUGGINGJMETERSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT StartDebuggingJMeterSceneResult : public ServiceResult
+			{
+			public:
+
+
+				StartDebuggingJMeterSceneResult();
+				explicit StartDebuggingJMeterSceneResult(const std::string &payload);
+				~StartDebuggingJMeterSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getReportId()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string reportId_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_STARTDEBUGGINGJMETERSCENERESULT_H_

pts/include/alibabacloud/pts/model/StartPtsSceneRequest.h

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

pts/include/alibabacloud/pts/model/StartPtsSceneResult.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_PTS_MODEL_STARTPTSSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_STARTPTSSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT StartPtsSceneResult : public ServiceResult
+			{
+			public:
+
+
+				StartPtsSceneResult();
+				explicit StartPtsSceneResult(const std::string &payload);
+				~StartPtsSceneResult();
+				std::string getMessage()const;
+				std::string getPlanId()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string planId_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_STARTPTSSCENERESULT_H_

pts/include/alibabacloud/pts/model/StartTestingJMeterSceneRequest.h

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

pts/include/alibabacloud/pts/model/StartTestingJMeterSceneResult.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_PTS_MODEL_STARTTESTINGJMETERSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_STARTTESTINGJMETERSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT StartTestingJMeterSceneResult : public ServiceResult
+			{
+			public:
+
+
+				StartTestingJMeterSceneResult();
+				explicit StartTestingJMeterSceneResult(const std::string &payload);
+				~StartTestingJMeterSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getReportId()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string reportId_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_STARTTESTINGJMETERSCENERESULT_H_

pts/include/alibabacloud/pts/model/StopDebugPtsSceneRequest.h

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_PTS_MODEL_STOPDEBUGPTSSCENEREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_STOPDEBUGPTSSCENEREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT StopDebugPtsSceneRequest : public RpcServiceRequest {
+public:
+	StopDebugPtsSceneRequest();
+	~StopDebugPtsSceneRequest();
+	std::string getSceneId() const;
+	void setSceneId(const std::string &sceneId);
+	std::string getPlanId() const;
+	void setPlanId(const std::string &planId);
+
+private:
+	std::string sceneId_;
+	std::string planId_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_STOPDEBUGPTSSCENEREQUEST_H_

pts/include/alibabacloud/pts/model/StopDebugPtsSceneResult.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_PTS_MODEL_STOPDEBUGPTSSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_STOPDEBUGPTSSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT StopDebugPtsSceneResult : public ServiceResult
+			{
+			public:
+
+
+				StopDebugPtsSceneResult();
+				explicit StopDebugPtsSceneResult(const std::string &payload);
+				~StopDebugPtsSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_STOPDEBUGPTSSCENERESULT_H_

pts/include/alibabacloud/pts/model/StopDebuggingJMeterSceneRequest.h

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

pts/include/alibabacloud/pts/model/StopDebuggingJMeterSceneResult.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_PTS_MODEL_STOPDEBUGGINGJMETERSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_STOPDEBUGGINGJMETERSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT StopDebuggingJMeterSceneResult : public ServiceResult
+			{
+			public:
+
+
+				StopDebuggingJMeterSceneResult();
+				explicit StopDebuggingJMeterSceneResult(const std::string &payload);
+				~StopDebuggingJMeterSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_STOPDEBUGGINGJMETERSCENERESULT_H_

pts/include/alibabacloud/pts/model/StopPtsSceneRequest.h

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

pts/include/alibabacloud/pts/model/StopPtsSceneResult.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_PTS_MODEL_STOPPTSSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_STOPPTSSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT StopPtsSceneResult : public ServiceResult
+			{
+			public:
+
+
+				StopPtsSceneResult();
+				explicit StopPtsSceneResult(const std::string &payload);
+				~StopPtsSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_STOPPTSSCENERESULT_H_

pts/include/alibabacloud/pts/model/StopTestingJMeterSceneRequest.h

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

pts/include/alibabacloud/pts/model/StopTestingJMeterSceneResult.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_PTS_MODEL_STOPTESTINGJMETERSCENERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_STOPTESTINGJMETERSCENERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT StopTestingJMeterSceneResult : public ServiceResult
+			{
+			public:
+
+
+				StopTestingJMeterSceneResult();
+				explicit StopTestingJMeterSceneResult(const std::string &payload);
+				~StopTestingJMeterSceneResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_STOPTESTINGJMETERSCENERESULT_H_

pts/include/alibabacloud/pts/model/UpdatePtsSceneBaseLineRequest.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_PTS_MODEL_UPDATEPTSSCENEBASELINEREQUEST_H_
+#define ALIBABACLOUD_PTS_MODEL_UPDATEPTSSCENEBASELINEREQUEST_H_
+
+#include <alibabacloud/pts/PTSExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace PTS {
+namespace Model {
+class ALIBABACLOUD_PTS_EXPORT UpdatePtsSceneBaseLineRequest : public RpcServiceRequest {
+public:
+	UpdatePtsSceneBaseLineRequest();
+	~UpdatePtsSceneBaseLineRequest();
+	std::string getSceneBaseline() const;
+	void setSceneBaseline(const std::string &sceneBaseline);
+	std::string getSceneId() const;
+	void setSceneId(const std::string &sceneId);
+	std::string getApiBaselines() const;
+	void setApiBaselines(const std::string &apiBaselines);
+
+private:
+	std::string sceneBaseline_;
+	std::string sceneId_;
+	std::string apiBaselines_;
+};
+} // namespace Model
+} // namespace PTS
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_PTS_MODEL_UPDATEPTSSCENEBASELINEREQUEST_H_

pts/include/alibabacloud/pts/model/UpdatePtsSceneBaseLineResult.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_PTS_MODEL_UPDATEPTSSCENEBASELINERESULT_H_
+#define ALIBABACLOUD_PTS_MODEL_UPDATEPTSSCENEBASELINERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/pts/PTSExport.h>
+
+namespace AlibabaCloud
+{
+	namespace PTS
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_PTS_EXPORT UpdatePtsSceneBaseLineResult : public ServiceResult
+			{
+			public:
+
+
+				UpdatePtsSceneBaseLineResult();
+				explicit UpdatePtsSceneBaseLineResult(const std::string &payload);
+				~UpdatePtsSceneBaseLineResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_PTS_MODEL_UPDATEPTSSCENEBASELINERESULT_H_

pts/src/PTSClient.cc

@@ -0,0 +1,1493 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/pts/PTSClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::PTS;
+using namespace AlibabaCloud::PTS::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "PTS";
+}
+
+PTSClient::PTSClient(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, "");
+}
+
+PTSClient::PTSClient(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, "");
+}
+
+PTSClient::PTSClient(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, "");
+}
+
+PTSClient::~PTSClient()
+{}
+
+PTSClient::AdjustJMeterSceneSpeedOutcome PTSClient::adjustJMeterSceneSpeed(const AdjustJMeterSceneSpeedRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AdjustJMeterSceneSpeedOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AdjustJMeterSceneSpeedOutcome(AdjustJMeterSceneSpeedResult(outcome.result()));
+	else
+		return AdjustJMeterSceneSpeedOutcome(outcome.error());
+}
+
+void PTSClient::adjustJMeterSceneSpeedAsync(const AdjustJMeterSceneSpeedRequest& request, const AdjustJMeterSceneSpeedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, adjustJMeterSceneSpeed(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::AdjustJMeterSceneSpeedOutcomeCallable PTSClient::adjustJMeterSceneSpeedCallable(const AdjustJMeterSceneSpeedRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AdjustJMeterSceneSpeedOutcome()>>(
+			[this, request]()
+			{
+			return this->adjustJMeterSceneSpeed(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::CreatePtsSceneOutcome PTSClient::createPtsScene(const CreatePtsSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreatePtsSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreatePtsSceneOutcome(CreatePtsSceneResult(outcome.result()));
+	else
+		return CreatePtsSceneOutcome(outcome.error());
+}
+
+void PTSClient::createPtsSceneAsync(const CreatePtsSceneRequest& request, const CreatePtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createPtsScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::CreatePtsSceneOutcomeCallable PTSClient::createPtsSceneCallable(const CreatePtsSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreatePtsSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->createPtsScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::CreatePtsSceneBaseLineFromReportOutcome PTSClient::createPtsSceneBaseLineFromReport(const CreatePtsSceneBaseLineFromReportRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreatePtsSceneBaseLineFromReportOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreatePtsSceneBaseLineFromReportOutcome(CreatePtsSceneBaseLineFromReportResult(outcome.result()));
+	else
+		return CreatePtsSceneBaseLineFromReportOutcome(outcome.error());
+}
+
+void PTSClient::createPtsSceneBaseLineFromReportAsync(const CreatePtsSceneBaseLineFromReportRequest& request, const CreatePtsSceneBaseLineFromReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createPtsSceneBaseLineFromReport(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::CreatePtsSceneBaseLineFromReportOutcomeCallable PTSClient::createPtsSceneBaseLineFromReportCallable(const CreatePtsSceneBaseLineFromReportRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreatePtsSceneBaseLineFromReportOutcome()>>(
+			[this, request]()
+			{
+			return this->createPtsSceneBaseLineFromReport(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::DeletePtsSceneOutcome PTSClient::deletePtsScene(const DeletePtsSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeletePtsSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeletePtsSceneOutcome(DeletePtsSceneResult(outcome.result()));
+	else
+		return DeletePtsSceneOutcome(outcome.error());
+}
+
+void PTSClient::deletePtsSceneAsync(const DeletePtsSceneRequest& request, const DeletePtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deletePtsScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::DeletePtsSceneOutcomeCallable PTSClient::deletePtsSceneCallable(const DeletePtsSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeletePtsSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->deletePtsScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::DeletePtsSceneBaseLineOutcome PTSClient::deletePtsSceneBaseLine(const DeletePtsSceneBaseLineRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeletePtsSceneBaseLineOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeletePtsSceneBaseLineOutcome(DeletePtsSceneBaseLineResult(outcome.result()));
+	else
+		return DeletePtsSceneBaseLineOutcome(outcome.error());
+}
+
+void PTSClient::deletePtsSceneBaseLineAsync(const DeletePtsSceneBaseLineRequest& request, const DeletePtsSceneBaseLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deletePtsSceneBaseLine(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::DeletePtsSceneBaseLineOutcomeCallable PTSClient::deletePtsSceneBaseLineCallable(const DeletePtsSceneBaseLineRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeletePtsSceneBaseLineOutcome()>>(
+			[this, request]()
+			{
+			return this->deletePtsSceneBaseLine(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::DeletePtsScenesOutcome PTSClient::deletePtsScenes(const DeletePtsScenesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeletePtsScenesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeletePtsScenesOutcome(DeletePtsScenesResult(outcome.result()));
+	else
+		return DeletePtsScenesOutcome(outcome.error());
+}
+
+void PTSClient::deletePtsScenesAsync(const DeletePtsScenesRequest& request, const DeletePtsScenesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deletePtsScenes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::DeletePtsScenesOutcomeCallable PTSClient::deletePtsScenesCallable(const DeletePtsScenesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeletePtsScenesOutcome()>>(
+			[this, request]()
+			{
+			return this->deletePtsScenes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetAllRegionsOutcome PTSClient::getAllRegions(const GetAllRegionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAllRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAllRegionsOutcome(GetAllRegionsResult(outcome.result()));
+	else
+		return GetAllRegionsOutcome(outcome.error());
+}
+
+void PTSClient::getAllRegionsAsync(const GetAllRegionsRequest& request, const GetAllRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAllRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetAllRegionsOutcomeCallable PTSClient::getAllRegionsCallable(const GetAllRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAllRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->getAllRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetJMeterLogsOutcome PTSClient::getJMeterLogs(const GetJMeterLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetJMeterLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetJMeterLogsOutcome(GetJMeterLogsResult(outcome.result()));
+	else
+		return GetJMeterLogsOutcome(outcome.error());
+}
+
+void PTSClient::getJMeterLogsAsync(const GetJMeterLogsRequest& request, const GetJMeterLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getJMeterLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetJMeterLogsOutcomeCallable PTSClient::getJMeterLogsCallable(const GetJMeterLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetJMeterLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->getJMeterLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetJMeterSampleMetricsOutcome PTSClient::getJMeterSampleMetrics(const GetJMeterSampleMetricsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetJMeterSampleMetricsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetJMeterSampleMetricsOutcome(GetJMeterSampleMetricsResult(outcome.result()));
+	else
+		return GetJMeterSampleMetricsOutcome(outcome.error());
+}
+
+void PTSClient::getJMeterSampleMetricsAsync(const GetJMeterSampleMetricsRequest& request, const GetJMeterSampleMetricsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getJMeterSampleMetrics(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetJMeterSampleMetricsOutcomeCallable PTSClient::getJMeterSampleMetricsCallable(const GetJMeterSampleMetricsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetJMeterSampleMetricsOutcome()>>(
+			[this, request]()
+			{
+			return this->getJMeterSampleMetrics(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetJMeterSamplingLogsOutcome PTSClient::getJMeterSamplingLogs(const GetJMeterSamplingLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetJMeterSamplingLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetJMeterSamplingLogsOutcome(GetJMeterSamplingLogsResult(outcome.result()));
+	else
+		return GetJMeterSamplingLogsOutcome(outcome.error());
+}
+
+void PTSClient::getJMeterSamplingLogsAsync(const GetJMeterSamplingLogsRequest& request, const GetJMeterSamplingLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getJMeterSamplingLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetJMeterSamplingLogsOutcomeCallable PTSClient::getJMeterSamplingLogsCallable(const GetJMeterSamplingLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetJMeterSamplingLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->getJMeterSamplingLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetJMeterSceneRunningDataOutcome PTSClient::getJMeterSceneRunningData(const GetJMeterSceneRunningDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetJMeterSceneRunningDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetJMeterSceneRunningDataOutcome(GetJMeterSceneRunningDataResult(outcome.result()));
+	else
+		return GetJMeterSceneRunningDataOutcome(outcome.error());
+}
+
+void PTSClient::getJMeterSceneRunningDataAsync(const GetJMeterSceneRunningDataRequest& request, const GetJMeterSceneRunningDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getJMeterSceneRunningData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetJMeterSceneRunningDataOutcomeCallable PTSClient::getJMeterSceneRunningDataCallable(const GetJMeterSceneRunningDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetJMeterSceneRunningDataOutcome()>>(
+			[this, request]()
+			{
+			return this->getJMeterSceneRunningData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetOpenJMeterSceneOutcome PTSClient::getOpenJMeterScene(const GetOpenJMeterSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetOpenJMeterSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetOpenJMeterSceneOutcome(GetOpenJMeterSceneResult(outcome.result()));
+	else
+		return GetOpenJMeterSceneOutcome(outcome.error());
+}
+
+void PTSClient::getOpenJMeterSceneAsync(const GetOpenJMeterSceneRequest& request, const GetOpenJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getOpenJMeterScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetOpenJMeterSceneOutcomeCallable PTSClient::getOpenJMeterSceneCallable(const GetOpenJMeterSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetOpenJMeterSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->getOpenJMeterScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetPtsReportDetailsOutcome PTSClient::getPtsReportDetails(const GetPtsReportDetailsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPtsReportDetailsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPtsReportDetailsOutcome(GetPtsReportDetailsResult(outcome.result()));
+	else
+		return GetPtsReportDetailsOutcome(outcome.error());
+}
+
+void PTSClient::getPtsReportDetailsAsync(const GetPtsReportDetailsRequest& request, const GetPtsReportDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPtsReportDetails(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetPtsReportDetailsOutcomeCallable PTSClient::getPtsReportDetailsCallable(const GetPtsReportDetailsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPtsReportDetailsOutcome()>>(
+			[this, request]()
+			{
+			return this->getPtsReportDetails(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetPtsReportsBySceneIdOutcome PTSClient::getPtsReportsBySceneId(const GetPtsReportsBySceneIdRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPtsReportsBySceneIdOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPtsReportsBySceneIdOutcome(GetPtsReportsBySceneIdResult(outcome.result()));
+	else
+		return GetPtsReportsBySceneIdOutcome(outcome.error());
+}
+
+void PTSClient::getPtsReportsBySceneIdAsync(const GetPtsReportsBySceneIdRequest& request, const GetPtsReportsBySceneIdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPtsReportsBySceneId(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetPtsReportsBySceneIdOutcomeCallable PTSClient::getPtsReportsBySceneIdCallable(const GetPtsReportsBySceneIdRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPtsReportsBySceneIdOutcome()>>(
+			[this, request]()
+			{
+			return this->getPtsReportsBySceneId(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetPtsSceneOutcome PTSClient::getPtsScene(const GetPtsSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPtsSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPtsSceneOutcome(GetPtsSceneResult(outcome.result()));
+	else
+		return GetPtsSceneOutcome(outcome.error());
+}
+
+void PTSClient::getPtsSceneAsync(const GetPtsSceneRequest& request, const GetPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPtsScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetPtsSceneOutcomeCallable PTSClient::getPtsSceneCallable(const GetPtsSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPtsSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->getPtsScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetPtsSceneBaseLineOutcome PTSClient::getPtsSceneBaseLine(const GetPtsSceneBaseLineRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPtsSceneBaseLineOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPtsSceneBaseLineOutcome(GetPtsSceneBaseLineResult(outcome.result()));
+	else
+		return GetPtsSceneBaseLineOutcome(outcome.error());
+}
+
+void PTSClient::getPtsSceneBaseLineAsync(const GetPtsSceneBaseLineRequest& request, const GetPtsSceneBaseLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPtsSceneBaseLine(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetPtsSceneBaseLineOutcomeCallable PTSClient::getPtsSceneBaseLineCallable(const GetPtsSceneBaseLineRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPtsSceneBaseLineOutcome()>>(
+			[this, request]()
+			{
+			return this->getPtsSceneBaseLine(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetPtsSceneRunningDataOutcome PTSClient::getPtsSceneRunningData(const GetPtsSceneRunningDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPtsSceneRunningDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPtsSceneRunningDataOutcome(GetPtsSceneRunningDataResult(outcome.result()));
+	else
+		return GetPtsSceneRunningDataOutcome(outcome.error());
+}
+
+void PTSClient::getPtsSceneRunningDataAsync(const GetPtsSceneRunningDataRequest& request, const GetPtsSceneRunningDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPtsSceneRunningData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetPtsSceneRunningDataOutcomeCallable PTSClient::getPtsSceneRunningDataCallable(const GetPtsSceneRunningDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPtsSceneRunningDataOutcome()>>(
+			[this, request]()
+			{
+			return this->getPtsSceneRunningData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetPtsSceneRunningStatusOutcome PTSClient::getPtsSceneRunningStatus(const GetPtsSceneRunningStatusRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPtsSceneRunningStatusOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPtsSceneRunningStatusOutcome(GetPtsSceneRunningStatusResult(outcome.result()));
+	else
+		return GetPtsSceneRunningStatusOutcome(outcome.error());
+}
+
+void PTSClient::getPtsSceneRunningStatusAsync(const GetPtsSceneRunningStatusRequest& request, const GetPtsSceneRunningStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPtsSceneRunningStatus(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetPtsSceneRunningStatusOutcomeCallable PTSClient::getPtsSceneRunningStatusCallable(const GetPtsSceneRunningStatusRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPtsSceneRunningStatusOutcome()>>(
+			[this, request]()
+			{
+			return this->getPtsSceneRunningStatus(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetUserVpcSecurityGroupOutcome PTSClient::getUserVpcSecurityGroup(const GetUserVpcSecurityGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetUserVpcSecurityGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetUserVpcSecurityGroupOutcome(GetUserVpcSecurityGroupResult(outcome.result()));
+	else
+		return GetUserVpcSecurityGroupOutcome(outcome.error());
+}
+
+void PTSClient::getUserVpcSecurityGroupAsync(const GetUserVpcSecurityGroupRequest& request, const GetUserVpcSecurityGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getUserVpcSecurityGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetUserVpcSecurityGroupOutcomeCallable PTSClient::getUserVpcSecurityGroupCallable(const GetUserVpcSecurityGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetUserVpcSecurityGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->getUserVpcSecurityGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetUserVpcVSwitchOutcome PTSClient::getUserVpcVSwitch(const GetUserVpcVSwitchRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetUserVpcVSwitchOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetUserVpcVSwitchOutcome(GetUserVpcVSwitchResult(outcome.result()));
+	else
+		return GetUserVpcVSwitchOutcome(outcome.error());
+}
+
+void PTSClient::getUserVpcVSwitchAsync(const GetUserVpcVSwitchRequest& request, const GetUserVpcVSwitchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getUserVpcVSwitch(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetUserVpcVSwitchOutcomeCallable PTSClient::getUserVpcVSwitchCallable(const GetUserVpcVSwitchRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetUserVpcVSwitchOutcome()>>(
+			[this, request]()
+			{
+			return this->getUserVpcVSwitch(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::GetUserVpcsOutcome PTSClient::getUserVpcs(const GetUserVpcsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetUserVpcsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetUserVpcsOutcome(GetUserVpcsResult(outcome.result()));
+	else
+		return GetUserVpcsOutcome(outcome.error());
+}
+
+void PTSClient::getUserVpcsAsync(const GetUserVpcsRequest& request, const GetUserVpcsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getUserVpcs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::GetUserVpcsOutcomeCallable PTSClient::getUserVpcsCallable(const GetUserVpcsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetUserVpcsOutcome()>>(
+			[this, request]()
+			{
+			return this->getUserVpcs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::ListEnvsOutcome PTSClient::listEnvs(const ListEnvsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListEnvsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListEnvsOutcome(ListEnvsResult(outcome.result()));
+	else
+		return ListEnvsOutcome(outcome.error());
+}
+
+void PTSClient::listEnvsAsync(const ListEnvsRequest& request, const ListEnvsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listEnvs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::ListEnvsOutcomeCallable PTSClient::listEnvsCallable(const ListEnvsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListEnvsOutcome()>>(
+			[this, request]()
+			{
+			return this->listEnvs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::ListJMeterReportsOutcome PTSClient::listJMeterReports(const ListJMeterReportsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListJMeterReportsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListJMeterReportsOutcome(ListJMeterReportsResult(outcome.result()));
+	else
+		return ListJMeterReportsOutcome(outcome.error());
+}
+
+void PTSClient::listJMeterReportsAsync(const ListJMeterReportsRequest& request, const ListJMeterReportsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listJMeterReports(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::ListJMeterReportsOutcomeCallable PTSClient::listJMeterReportsCallable(const ListJMeterReportsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListJMeterReportsOutcome()>>(
+			[this, request]()
+			{
+			return this->listJMeterReports(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::ListOpenJMeterScenesOutcome PTSClient::listOpenJMeterScenes(const ListOpenJMeterScenesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListOpenJMeterScenesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListOpenJMeterScenesOutcome(ListOpenJMeterScenesResult(outcome.result()));
+	else
+		return ListOpenJMeterScenesOutcome(outcome.error());
+}
+
+void PTSClient::listOpenJMeterScenesAsync(const ListOpenJMeterScenesRequest& request, const ListOpenJMeterScenesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listOpenJMeterScenes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::ListOpenJMeterScenesOutcomeCallable PTSClient::listOpenJMeterScenesCallable(const ListOpenJMeterScenesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListOpenJMeterScenesOutcome()>>(
+			[this, request]()
+			{
+			return this->listOpenJMeterScenes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::ListPtsSceneOutcome PTSClient::listPtsScene(const ListPtsSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListPtsSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListPtsSceneOutcome(ListPtsSceneResult(outcome.result()));
+	else
+		return ListPtsSceneOutcome(outcome.error());
+}
+
+void PTSClient::listPtsSceneAsync(const ListPtsSceneRequest& request, const ListPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listPtsScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::ListPtsSceneOutcomeCallable PTSClient::listPtsSceneCallable(const ListPtsSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListPtsSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->listPtsScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::ModifyPtsSceneOutcome PTSClient::modifyPtsScene(const ModifyPtsSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyPtsSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyPtsSceneOutcome(ModifyPtsSceneResult(outcome.result()));
+	else
+		return ModifyPtsSceneOutcome(outcome.error());
+}
+
+void PTSClient::modifyPtsSceneAsync(const ModifyPtsSceneRequest& request, const ModifyPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyPtsScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::ModifyPtsSceneOutcomeCallable PTSClient::modifyPtsSceneCallable(const ModifyPtsSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyPtsSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyPtsScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::RemoveEnvOutcome PTSClient::removeEnv(const RemoveEnvRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveEnvOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveEnvOutcome(RemoveEnvResult(outcome.result()));
+	else
+		return RemoveEnvOutcome(outcome.error());
+}
+
+void PTSClient::removeEnvAsync(const RemoveEnvRequest& request, const RemoveEnvAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeEnv(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::RemoveEnvOutcomeCallable PTSClient::removeEnvCallable(const RemoveEnvRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveEnvOutcome()>>(
+			[this, request]()
+			{
+			return this->removeEnv(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::RemoveOpenJMeterSceneOutcome PTSClient::removeOpenJMeterScene(const RemoveOpenJMeterSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveOpenJMeterSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveOpenJMeterSceneOutcome(RemoveOpenJMeterSceneResult(outcome.result()));
+	else
+		return RemoveOpenJMeterSceneOutcome(outcome.error());
+}
+
+void PTSClient::removeOpenJMeterSceneAsync(const RemoveOpenJMeterSceneRequest& request, const RemoveOpenJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeOpenJMeterScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::RemoveOpenJMeterSceneOutcomeCallable PTSClient::removeOpenJMeterSceneCallable(const RemoveOpenJMeterSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveOpenJMeterSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->removeOpenJMeterScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::SaveEnvOutcome PTSClient::saveEnv(const SaveEnvRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SaveEnvOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SaveEnvOutcome(SaveEnvResult(outcome.result()));
+	else
+		return SaveEnvOutcome(outcome.error());
+}
+
+void PTSClient::saveEnvAsync(const SaveEnvRequest& request, const SaveEnvAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, saveEnv(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::SaveEnvOutcomeCallable PTSClient::saveEnvCallable(const SaveEnvRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SaveEnvOutcome()>>(
+			[this, request]()
+			{
+			return this->saveEnv(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::SaveOpenJMeterSceneOutcome PTSClient::saveOpenJMeterScene(const SaveOpenJMeterSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SaveOpenJMeterSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SaveOpenJMeterSceneOutcome(SaveOpenJMeterSceneResult(outcome.result()));
+	else
+		return SaveOpenJMeterSceneOutcome(outcome.error());
+}
+
+void PTSClient::saveOpenJMeterSceneAsync(const SaveOpenJMeterSceneRequest& request, const SaveOpenJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, saveOpenJMeterScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::SaveOpenJMeterSceneOutcomeCallable PTSClient::saveOpenJMeterSceneCallable(const SaveOpenJMeterSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SaveOpenJMeterSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->saveOpenJMeterScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::SavePtsSceneOutcome PTSClient::savePtsScene(const SavePtsSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SavePtsSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SavePtsSceneOutcome(SavePtsSceneResult(outcome.result()));
+	else
+		return SavePtsSceneOutcome(outcome.error());
+}
+
+void PTSClient::savePtsSceneAsync(const SavePtsSceneRequest& request, const SavePtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, savePtsScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::SavePtsSceneOutcomeCallable PTSClient::savePtsSceneCallable(const SavePtsSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SavePtsSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->savePtsScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::StartDebugPtsSceneOutcome PTSClient::startDebugPtsScene(const StartDebugPtsSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartDebugPtsSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartDebugPtsSceneOutcome(StartDebugPtsSceneResult(outcome.result()));
+	else
+		return StartDebugPtsSceneOutcome(outcome.error());
+}
+
+void PTSClient::startDebugPtsSceneAsync(const StartDebugPtsSceneRequest& request, const StartDebugPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startDebugPtsScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::StartDebugPtsSceneOutcomeCallable PTSClient::startDebugPtsSceneCallable(const StartDebugPtsSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartDebugPtsSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->startDebugPtsScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::StartDebuggingJMeterSceneOutcome PTSClient::startDebuggingJMeterScene(const StartDebuggingJMeterSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartDebuggingJMeterSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartDebuggingJMeterSceneOutcome(StartDebuggingJMeterSceneResult(outcome.result()));
+	else
+		return StartDebuggingJMeterSceneOutcome(outcome.error());
+}
+
+void PTSClient::startDebuggingJMeterSceneAsync(const StartDebuggingJMeterSceneRequest& request, const StartDebuggingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startDebuggingJMeterScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::StartDebuggingJMeterSceneOutcomeCallable PTSClient::startDebuggingJMeterSceneCallable(const StartDebuggingJMeterSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartDebuggingJMeterSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->startDebuggingJMeterScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::StartPtsSceneOutcome PTSClient::startPtsScene(const StartPtsSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartPtsSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartPtsSceneOutcome(StartPtsSceneResult(outcome.result()));
+	else
+		return StartPtsSceneOutcome(outcome.error());
+}
+
+void PTSClient::startPtsSceneAsync(const StartPtsSceneRequest& request, const StartPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startPtsScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::StartPtsSceneOutcomeCallable PTSClient::startPtsSceneCallable(const StartPtsSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartPtsSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->startPtsScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::StartTestingJMeterSceneOutcome PTSClient::startTestingJMeterScene(const StartTestingJMeterSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartTestingJMeterSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartTestingJMeterSceneOutcome(StartTestingJMeterSceneResult(outcome.result()));
+	else
+		return StartTestingJMeterSceneOutcome(outcome.error());
+}
+
+void PTSClient::startTestingJMeterSceneAsync(const StartTestingJMeterSceneRequest& request, const StartTestingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startTestingJMeterScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::StartTestingJMeterSceneOutcomeCallable PTSClient::startTestingJMeterSceneCallable(const StartTestingJMeterSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartTestingJMeterSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->startTestingJMeterScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::StopDebugPtsSceneOutcome PTSClient::stopDebugPtsScene(const StopDebugPtsSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopDebugPtsSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopDebugPtsSceneOutcome(StopDebugPtsSceneResult(outcome.result()));
+	else
+		return StopDebugPtsSceneOutcome(outcome.error());
+}
+
+void PTSClient::stopDebugPtsSceneAsync(const StopDebugPtsSceneRequest& request, const StopDebugPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopDebugPtsScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::StopDebugPtsSceneOutcomeCallable PTSClient::stopDebugPtsSceneCallable(const StopDebugPtsSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopDebugPtsSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->stopDebugPtsScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::StopDebuggingJMeterSceneOutcome PTSClient::stopDebuggingJMeterScene(const StopDebuggingJMeterSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopDebuggingJMeterSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopDebuggingJMeterSceneOutcome(StopDebuggingJMeterSceneResult(outcome.result()));
+	else
+		return StopDebuggingJMeterSceneOutcome(outcome.error());
+}
+
+void PTSClient::stopDebuggingJMeterSceneAsync(const StopDebuggingJMeterSceneRequest& request, const StopDebuggingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopDebuggingJMeterScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::StopDebuggingJMeterSceneOutcomeCallable PTSClient::stopDebuggingJMeterSceneCallable(const StopDebuggingJMeterSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopDebuggingJMeterSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->stopDebuggingJMeterScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::StopPtsSceneOutcome PTSClient::stopPtsScene(const StopPtsSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopPtsSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopPtsSceneOutcome(StopPtsSceneResult(outcome.result()));
+	else
+		return StopPtsSceneOutcome(outcome.error());
+}
+
+void PTSClient::stopPtsSceneAsync(const StopPtsSceneRequest& request, const StopPtsSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopPtsScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::StopPtsSceneOutcomeCallable PTSClient::stopPtsSceneCallable(const StopPtsSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopPtsSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->stopPtsScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::StopTestingJMeterSceneOutcome PTSClient::stopTestingJMeterScene(const StopTestingJMeterSceneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopTestingJMeterSceneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopTestingJMeterSceneOutcome(StopTestingJMeterSceneResult(outcome.result()));
+	else
+		return StopTestingJMeterSceneOutcome(outcome.error());
+}
+
+void PTSClient::stopTestingJMeterSceneAsync(const StopTestingJMeterSceneRequest& request, const StopTestingJMeterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopTestingJMeterScene(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::StopTestingJMeterSceneOutcomeCallable PTSClient::stopTestingJMeterSceneCallable(const StopTestingJMeterSceneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopTestingJMeterSceneOutcome()>>(
+			[this, request]()
+			{
+			return this->stopTestingJMeterScene(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PTSClient::UpdatePtsSceneBaseLineOutcome PTSClient::updatePtsSceneBaseLine(const UpdatePtsSceneBaseLineRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdatePtsSceneBaseLineOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdatePtsSceneBaseLineOutcome(UpdatePtsSceneBaseLineResult(outcome.result()));
+	else
+		return UpdatePtsSceneBaseLineOutcome(outcome.error());
+}
+
+void PTSClient::updatePtsSceneBaseLineAsync(const UpdatePtsSceneBaseLineRequest& request, const UpdatePtsSceneBaseLineAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updatePtsSceneBaseLine(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PTSClient::UpdatePtsSceneBaseLineOutcomeCallable PTSClient::updatePtsSceneBaseLineCallable(const UpdatePtsSceneBaseLineRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdatePtsSceneBaseLineOutcome()>>(
+			[this, request]()
+			{
+			return this->updatePtsSceneBaseLine(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

pts/src/model/AdjustJMeterSceneSpeedRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/pts/model/AdjustJMeterSceneSpeedRequest.h>
+
+using AlibabaCloud::PTS::Model::AdjustJMeterSceneSpeedRequest;
+
+AdjustJMeterSceneSpeedRequest::AdjustJMeterSceneSpeedRequest()
+    : RpcServiceRequest("pts", "2020-10-20", "AdjustJMeterSceneSpeed") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+AdjustJMeterSceneSpeedRequest::~AdjustJMeterSceneSpeedRequest() {}
+
+std::string AdjustJMeterSceneSpeedRequest::getReportId() const {
+  return reportId_;
+}
+
+void AdjustJMeterSceneSpeedRequest::setReportId(const std::string &reportId) {
+  reportId_ = reportId;
+  setParameter(std::string("ReportId"), reportId);
+}
+
+int AdjustJMeterSceneSpeedRequest::getSpeed() const {
+  return speed_;
+}
+
+void AdjustJMeterSceneSpeedRequest::setSpeed(int speed) {
+  speed_ = speed;
+  setParameter(std::string("Speed"), std::to_string(speed));
+}
+

pts/src/model/AdjustJMeterSceneSpeedResult.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/pts/model/AdjustJMeterSceneSpeedResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::PTS;
+using namespace AlibabaCloud::PTS::Model;
+
+AdjustJMeterSceneSpeedResult::AdjustJMeterSceneSpeedResult() :
+	ServiceResult()
+{}
+
+AdjustJMeterSceneSpeedResult::AdjustJMeterSceneSpeedResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+AdjustJMeterSceneSpeedResult::~AdjustJMeterSceneSpeedResult()
+{}
+
+void AdjustJMeterSceneSpeedResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ReportId"].isNull())
+		reportId_ = value["ReportId"].asString();
+
+}
+
+std::string AdjustJMeterSceneSpeedResult::getMessage()const
+{
+	return message_;
+}
+
+int AdjustJMeterSceneSpeedResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string AdjustJMeterSceneSpeedResult::getReportId()const
+{
+	return reportId_;
+}
+
+std::string AdjustJMeterSceneSpeedResult::getCode()const
+{
+	return code_;
+}
+
+bool AdjustJMeterSceneSpeedResult::getSuccess()const
+{
+	return success_;
+}
+

pts/src/model/CreatePtsSceneBaseLineFromReportRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/pts/model/CreatePtsSceneBaseLineFromReportRequest.h>
+
+using AlibabaCloud::PTS::Model::CreatePtsSceneBaseLineFromReportRequest;
+
+CreatePtsSceneBaseLineFromReportRequest::CreatePtsSceneBaseLineFromReportRequest()
+    : RpcServiceRequest("pts", "2020-10-20", "CreatePtsSceneBaseLineFromReport") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreatePtsSceneBaseLineFromReportRequest::~CreatePtsSceneBaseLineFromReportRequest() {}
+
+std::string CreatePtsSceneBaseLineFromReportRequest::getReportId() const {
+  return reportId_;
+}
+
+void CreatePtsSceneBaseLineFromReportRequest::setReportId(const std::string &reportId) {
+  reportId_ = reportId;
+  setParameter(std::string("ReportId"), reportId);
+}
+
+std::string CreatePtsSceneBaseLineFromReportRequest::getSceneId() const {
+  return sceneId_;
+}
+
+void CreatePtsSceneBaseLineFromReportRequest::setSceneId(const std::string &sceneId) {
+  sceneId_ = sceneId;
+  setParameter(std::string("SceneId"), sceneId);
+}
+

pts/src/model/CreatePtsSceneBaseLineFromReportResult.cc

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

pts/src/model/CreatePtsSceneRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/pts/model/CreatePtsSceneRequest.h>
+
+using AlibabaCloud::PTS::Model::CreatePtsSceneRequest;
+
+CreatePtsSceneRequest::CreatePtsSceneRequest()
+    : RpcServiceRequest("pts", "2020-10-20", "CreatePtsScene") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreatePtsSceneRequest::~CreatePtsSceneRequest() {}
+
+std::string CreatePtsSceneRequest::getScene() const {
+  return scene_;
+}
+
+void CreatePtsSceneRequest::setScene(const std::string &scene) {
+  scene_ = scene;
+  setParameter(std::string("Scene"), scene);
+}
+

pts/src/model/CreatePtsSceneResult.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/pts/model/CreatePtsSceneResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::PTS;
+using namespace AlibabaCloud::PTS::Model;
+
+CreatePtsSceneResult::CreatePtsSceneResult() :
+	ServiceResult()
+{}
+
+CreatePtsSceneResult::CreatePtsSceneResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreatePtsSceneResult::~CreatePtsSceneResult()
+{}
+
+void CreatePtsSceneResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["SceneId"].isNull())
+		sceneId_ = value["SceneId"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string CreatePtsSceneResult::getSceneId()const
+{
+	return sceneId_;
+}
+
+std::string CreatePtsSceneResult::getMessage()const
+{
+	return message_;
+}
+
+int CreatePtsSceneResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string CreatePtsSceneResult::getCode()const
+{
+	return code_;
+}
+
+bool CreatePtsSceneResult::getSuccess()const
+{
+	return success_;
+}
+

pts/src/model/DeletePtsSceneBaseLineRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/pts/model/DeletePtsSceneBaseLineRequest.h>
+
+using AlibabaCloud::PTS::Model::DeletePtsSceneBaseLineRequest;
+
+DeletePtsSceneBaseLineRequest::DeletePtsSceneBaseLineRequest()
+    : RpcServiceRequest("pts", "2020-10-20", "DeletePtsSceneBaseLine") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeletePtsSceneBaseLineRequest::~DeletePtsSceneBaseLineRequest() {}
+
+std::string DeletePtsSceneBaseLineRequest::getSceneId() const {
+  return sceneId_;
+}
+
+void DeletePtsSceneBaseLineRequest::setSceneId(const std::string &sceneId) {
+  sceneId_ = sceneId;
+  setParameter(std::string("SceneId"), sceneId);
+}
+

pts/src/model/DeletePtsSceneBaseLineResult.cc

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

pts/src/model/DeletePtsSceneRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/pts/model/DeletePtsSceneRequest.h>
+
+using AlibabaCloud::PTS::Model::DeletePtsSceneRequest;
+
+DeletePtsSceneRequest::DeletePtsSceneRequest()
+    : RpcServiceRequest("pts", "2020-10-20", "DeletePtsScene") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeletePtsSceneRequest::~DeletePtsSceneRequest() {}
+
+std::string DeletePtsSceneRequest::getSceneId() const {
+  return sceneId_;
+}
+
+void DeletePtsSceneRequest::setSceneId(const std::string &sceneId) {
+  sceneId_ = sceneId;
+  setParameter(std::string("SceneId"), sceneId);
+}
+

pts/src/model/DeletePtsSceneResult.cc

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

pts/src/model/DeletePtsScenesRequest.cc

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/pts/model/DeletePtsScenesRequest.h>
+
+using AlibabaCloud::PTS::Model::DeletePtsScenesRequest;
+
+DeletePtsScenesRequest::DeletePtsScenesRequest()
+    : RpcServiceRequest("pts", "2020-10-20", "DeletePtsScenes") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeletePtsScenesRequest::~DeletePtsScenesRequest() {}
+
+std::string DeletePtsScenesRequest::getSceneIds() const {
+  return sceneIds_;
+}
+
+void DeletePtsScenesRequest::setSceneIds(const std::string &sceneIds) {
+  sceneIds_ = sceneIds;
+  setParameter(std::string("SceneIds"), sceneIds);
+}
+

pts/src/model/DeletePtsScenesResult.cc

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

pts/src/model/GetAllRegionsRequest.cc

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/pts/model/GetAllRegionsRequest.h>
+
+using AlibabaCloud::PTS::Model::GetAllRegionsRequest;
+
+GetAllRegionsRequest::GetAllRegionsRequest()
+    : RpcServiceRequest("pts", "2020-10-20", "GetAllRegions") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetAllRegionsRequest::~GetAllRegionsRequest() {}
+

pts/src/model/GetAllRegionsResult.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/pts/model/GetAllRegionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::PTS;
+using namespace AlibabaCloud::PTS::Model;
+
+GetAllRegionsResult::GetAllRegionsResult() :
+	ServiceResult()
+{}
+
+GetAllRegionsResult::GetAllRegionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetAllRegionsResult::~GetAllRegionsResult()
+{}
+
+void GetAllRegionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["AllRegions"].isNull())
+		allRegions_ = value["AllRegions"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string GetAllRegionsResult::getMessage()const
+{
+	return message_;
+}
+
+std::string GetAllRegionsResult::getAllRegions()const
+{
+	return allRegions_;
+}
+
+int GetAllRegionsResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::string GetAllRegionsResult::getCode()const
+{
+	return code_;
+}
+
+bool GetAllRegionsResult::getSuccess()const
+{
+	return success_;
+}
+

pts/src/model/GetJMeterLogsRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/pts/model/GetJMeterLogsRequest.h>
+
+using AlibabaCloud::PTS::Model::GetJMeterLogsRequest;
+
+GetJMeterLogsRequest::GetJMeterLogsRequest()
+    : RpcServiceRequest("pts", "2020-10-20", "GetJMeterLogs") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetJMeterLogsRequest::~GetJMeterLogsRequest() {}
+
+int GetJMeterLogsRequest::getAgentIndex() const {
+  return agentIndex_;
+}
+
+void GetJMeterLogsRequest::setAgentIndex(int agentIndex) {
+  agentIndex_ = agentIndex;
+  setParameter(std::string("AgentIndex"), std::to_string(agentIndex));
+}
+
+std::string GetJMeterLogsRequest::getReportId() const {
+  return reportId_;
+}
+
+void GetJMeterLogsRequest::setReportId(const std::string &reportId) {
+  reportId_ = reportId;
+  setParameter(std::string("ReportId"), reportId);
+}
+
+std::string GetJMeterLogsRequest::getLevel() const {
+  return level_;
+}
+
+void GetJMeterLogsRequest::setLevel(const std::string &level) {
+  level_ = level;
+  setParameter(std::string("Level"), level);
+}
+
+long GetJMeterLogsRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetJMeterLogsRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+long GetJMeterLogsRequest::getBeginTime() const {
+  return beginTime_;
+}
+
+void GetJMeterLogsRequest::setBeginTime(long beginTime) {
+  beginTime_ = beginTime;
+  setParameter(std::string("BeginTime"), std::to_string(beginTime));
+}
+
+std::string GetJMeterLogsRequest::getThread() const {
+  return thread_;
+}
+
+void GetJMeterLogsRequest::setThread(const std::string &thread) {
+  thread_ = thread;
+  setParameter(std::string("Thread"), thread);
+}
+
+int GetJMeterLogsRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void GetJMeterLogsRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+int GetJMeterLogsRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void GetJMeterLogsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string GetJMeterLogsRequest::getKeyword() const {
+  return keyword_;
+}
+
+void GetJMeterLogsRequest::setKeyword(const std::string &keyword) {
+  keyword_ = keyword;
+  setParameter(std::string("Keyword"), keyword);
+}
+