Automatically generate sdk tasks.

CHANGELOG

@@ -1,3 +1,6 @@
+2022-08-05 Version: 1.36.1218
+- Automatically generate sdk tasks.
+
 2022-08-03 Version: 1.36.1217
 - Supported more query conditions when searching resource group.
 

VERSION

@@ -1 +1 @@
-1.36.1217
+1.36.1218

lmztest/CMakeLists.txt

@@ -0,0 +1,158 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(lmztest_public_header 
+	include/alibabacloud/lmztest/LmzTestClient.h
+	include/alibabacloud/lmztest/LmzTestExport.h )
+
+set(lmztest_public_header_model 
+	include/alibabacloud/lmztest/model/AAbckRequest.h
+	include/alibabacloud/lmztest/model/AAbckResult.h
+	include/alibabacloud/lmztest/model/AndBackRequest.h
+	include/alibabacloud/lmztest/model/AndBackResult.h
+	include/alibabacloud/lmztest/model/DataRateLimitTestRequest.h
+	include/alibabacloud/lmztest/model/DataRateLimitTestResult.h
+	include/alibabacloud/lmztest/model/DemoGrayReleaseTestRequest.h
+	include/alibabacloud/lmztest/model/DemoGrayReleaseTestResult.h
+	include/alibabacloud/lmztest/model/DemoGrayReleaseTestTwoRequest.h
+	include/alibabacloud/lmztest/model/DemoGrayReleaseTestTwoResult.h
+	include/alibabacloud/lmztest/model/DemoGreyReleaseTestRequest.h
+	include/alibabacloud/lmztest/model/DemoGreyReleaseTestResult.h
+	include/alibabacloud/lmztest/model/DemoHsfNineResponseRequest.h
+	include/alibabacloud/lmztest/model/DemoHsfNineResponseResult.h
+	include/alibabacloud/lmztest/model/DemoHsfSixTestRequest.h
+	include/alibabacloud/lmztest/model/DemoHsfSixTestResult.h
+	include/alibabacloud/lmztest/model/DemoHttpComplexResponseRequest.h
+	include/alibabacloud/lmztest/model/DemoHttpComplexResponseResult.h
+	include/alibabacloud/lmztest/model/DescribeDisksRequest.h
+	include/alibabacloud/lmztest/model/DescribeDisksResult.h
+	include/alibabacloud/lmztest/model/GetPackageStorageCredentialRequest.h
+	include/alibabacloud/lmztest/model/GetPackageStorageCredentialResult.h
+	include/alibabacloud/lmztest/model/GrayReleaseDemoRequest.h
+	include/alibabacloud/lmztest/model/GrayReleaseDemoResult.h
+	include/alibabacloud/lmztest/model/ListProductsByPopCodeRequest.h
+	include/alibabacloud/lmztest/model/ListProductsByPopCodeResult.h
+	include/alibabacloud/lmztest/model/LjxTestRequest.h
+	include/alibabacloud/lmztest/model/LjxTestResult.h
+	include/alibabacloud/lmztest/model/ReqBeanTestRequest.h
+	include/alibabacloud/lmztest/model/ReqBeanTestResult.h
+	include/alibabacloud/lmztest/model/RomeGetExecutionResultRequest.h
+	include/alibabacloud/lmztest/model/RomeGetExecutionResultResult.h
+	include/alibabacloud/lmztest/model/RpcHttpRequest.h
+	include/alibabacloud/lmztest/model/RpcHttpResult.h
+	include/alibabacloud/lmztest/model/TestPutApiAndGetApiRequest.h
+	include/alibabacloud/lmztest/model/TestPutApiAndGetApiResult.h
+	include/alibabacloud/lmztest/model/UpdateListenerRequest.h
+	include/alibabacloud/lmztest/model/UpdateListenerResult.h )
+
+set(lmztest_src 
+	src/LmzTestClient.cc
+	src/model/AAbckRequest.cc
+	src/model/AAbckResult.cc
+	src/model/AndBackRequest.cc
+	src/model/AndBackResult.cc
+	src/model/DataRateLimitTestRequest.cc
+	src/model/DataRateLimitTestResult.cc
+	src/model/DemoGrayReleaseTestRequest.cc
+	src/model/DemoGrayReleaseTestResult.cc
+	src/model/DemoGrayReleaseTestTwoRequest.cc
+	src/model/DemoGrayReleaseTestTwoResult.cc
+	src/model/DemoGreyReleaseTestRequest.cc
+	src/model/DemoGreyReleaseTestResult.cc
+	src/model/DemoHsfNineResponseRequest.cc
+	src/model/DemoHsfNineResponseResult.cc
+	src/model/DemoHsfSixTestRequest.cc
+	src/model/DemoHsfSixTestResult.cc
+	src/model/DemoHttpComplexResponseRequest.cc
+	src/model/DemoHttpComplexResponseResult.cc
+	src/model/DescribeDisksRequest.cc
+	src/model/DescribeDisksResult.cc
+	src/model/GetPackageStorageCredentialRequest.cc
+	src/model/GetPackageStorageCredentialResult.cc
+	src/model/GrayReleaseDemoRequest.cc
+	src/model/GrayReleaseDemoResult.cc
+	src/model/ListProductsByPopCodeRequest.cc
+	src/model/ListProductsByPopCodeResult.cc
+	src/model/LjxTestRequest.cc
+	src/model/LjxTestResult.cc
+	src/model/ReqBeanTestRequest.cc
+	src/model/ReqBeanTestResult.cc
+	src/model/RomeGetExecutionResultRequest.cc
+	src/model/RomeGetExecutionResultResult.cc
+	src/model/RpcHttpRequest.cc
+	src/model/RpcHttpResult.cc
+	src/model/TestPutApiAndGetApiRequest.cc
+	src/model/TestPutApiAndGetApiResult.cc
+	src/model/UpdateListenerRequest.cc
+	src/model/UpdateListenerResult.cc )
+
+add_library(lmztest ${LIB_TYPE}
+	${lmztest_public_header}
+	${lmztest_public_header_model}
+	${lmztest_src})
+
+set_target_properties(lmztest
+	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}lmztest
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(lmztest
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_LMZTEST_LIBRARY)
+endif()
+
+target_include_directories(lmztest
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(lmztest
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(lmztest
+		jsoncpp)
+	target_include_directories(lmztest
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(lmztest
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(lmztest
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(lmztest
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(lmztest
+		jsoncpp)
+endif()
+
+install(FILES ${lmztest_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/lmztest)
+install(FILES ${lmztest_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/lmztest/model)
+install(TARGETS lmztest
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

lmztest/include/alibabacloud/lmztest/LmzTestClient.h

@@ -0,0 +1,198 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_LMZTEST_LMZTESTCLIENT_H_
+#define ALIBABACLOUD_LMZTEST_LMZTESTCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "LmzTestExport.h"
+#include "model/AAbckRequest.h"
+#include "model/AAbckResult.h"
+#include "model/AndBackRequest.h"
+#include "model/AndBackResult.h"
+#include "model/DataRateLimitTestRequest.h"
+#include "model/DataRateLimitTestResult.h"
+#include "model/DemoGrayReleaseTestRequest.h"
+#include "model/DemoGrayReleaseTestResult.h"
+#include "model/DemoGrayReleaseTestTwoRequest.h"
+#include "model/DemoGrayReleaseTestTwoResult.h"
+#include "model/DemoGreyReleaseTestRequest.h"
+#include "model/DemoGreyReleaseTestResult.h"
+#include "model/DemoHsfNineResponseRequest.h"
+#include "model/DemoHsfNineResponseResult.h"
+#include "model/DemoHsfSixTestRequest.h"
+#include "model/DemoHsfSixTestResult.h"
+#include "model/DemoHttpComplexResponseRequest.h"
+#include "model/DemoHttpComplexResponseResult.h"
+#include "model/DescribeDisksRequest.h"
+#include "model/DescribeDisksResult.h"
+#include "model/GetPackageStorageCredentialRequest.h"
+#include "model/GetPackageStorageCredentialResult.h"
+#include "model/GrayReleaseDemoRequest.h"
+#include "model/GrayReleaseDemoResult.h"
+#include "model/ListProductsByPopCodeRequest.h"
+#include "model/ListProductsByPopCodeResult.h"
+#include "model/LjxTestRequest.h"
+#include "model/LjxTestResult.h"
+#include "model/ReqBeanTestRequest.h"
+#include "model/ReqBeanTestResult.h"
+#include "model/RomeGetExecutionResultRequest.h"
+#include "model/RomeGetExecutionResultResult.h"
+#include "model/RpcHttpRequest.h"
+#include "model/RpcHttpResult.h"
+#include "model/TestPutApiAndGetApiRequest.h"
+#include "model/TestPutApiAndGetApiResult.h"
+#include "model/UpdateListenerRequest.h"
+#include "model/UpdateListenerResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace LmzTest
+	{
+		class ALIBABACLOUD_LMZTEST_EXPORT LmzTestClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::AAbckResult> AAbckOutcome;
+			typedef std::future<AAbckOutcome> AAbckOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::AAbckRequest&, const AAbckOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AAbckAsyncHandler;
+			typedef Outcome<Error, Model::AndBackResult> AndBackOutcome;
+			typedef std::future<AndBackOutcome> AndBackOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::AndBackRequest&, const AndBackOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AndBackAsyncHandler;
+			typedef Outcome<Error, Model::DataRateLimitTestResult> DataRateLimitTestOutcome;
+			typedef std::future<DataRateLimitTestOutcome> DataRateLimitTestOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::DataRateLimitTestRequest&, const DataRateLimitTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DataRateLimitTestAsyncHandler;
+			typedef Outcome<Error, Model::DemoGrayReleaseTestResult> DemoGrayReleaseTestOutcome;
+			typedef std::future<DemoGrayReleaseTestOutcome> DemoGrayReleaseTestOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::DemoGrayReleaseTestRequest&, const DemoGrayReleaseTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoGrayReleaseTestAsyncHandler;
+			typedef Outcome<Error, Model::DemoGrayReleaseTestTwoResult> DemoGrayReleaseTestTwoOutcome;
+			typedef std::future<DemoGrayReleaseTestTwoOutcome> DemoGrayReleaseTestTwoOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::DemoGrayReleaseTestTwoRequest&, const DemoGrayReleaseTestTwoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoGrayReleaseTestTwoAsyncHandler;
+			typedef Outcome<Error, Model::DemoGreyReleaseTestResult> DemoGreyReleaseTestOutcome;
+			typedef std::future<DemoGreyReleaseTestOutcome> DemoGreyReleaseTestOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::DemoGreyReleaseTestRequest&, const DemoGreyReleaseTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoGreyReleaseTestAsyncHandler;
+			typedef Outcome<Error, Model::DemoHsfNineResponseResult> DemoHsfNineResponseOutcome;
+			typedef std::future<DemoHsfNineResponseOutcome> DemoHsfNineResponseOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::DemoHsfNineResponseRequest&, const DemoHsfNineResponseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoHsfNineResponseAsyncHandler;
+			typedef Outcome<Error, Model::DemoHsfSixTestResult> DemoHsfSixTestOutcome;
+			typedef std::future<DemoHsfSixTestOutcome> DemoHsfSixTestOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::DemoHsfSixTestRequest&, const DemoHsfSixTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoHsfSixTestAsyncHandler;
+			typedef Outcome<Error, Model::DemoHttpComplexResponseResult> DemoHttpComplexResponseOutcome;
+			typedef std::future<DemoHttpComplexResponseOutcome> DemoHttpComplexResponseOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::DemoHttpComplexResponseRequest&, const DemoHttpComplexResponseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DemoHttpComplexResponseAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDisksResult> DescribeDisksOutcome;
+			typedef std::future<DescribeDisksOutcome> DescribeDisksOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::DescribeDisksRequest&, const DescribeDisksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDisksAsyncHandler;
+			typedef Outcome<Error, Model::GetPackageStorageCredentialResult> GetPackageStorageCredentialOutcome;
+			typedef std::future<GetPackageStorageCredentialOutcome> GetPackageStorageCredentialOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::GetPackageStorageCredentialRequest&, const GetPackageStorageCredentialOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPackageStorageCredentialAsyncHandler;
+			typedef Outcome<Error, Model::GrayReleaseDemoResult> GrayReleaseDemoOutcome;
+			typedef std::future<GrayReleaseDemoOutcome> GrayReleaseDemoOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::GrayReleaseDemoRequest&, const GrayReleaseDemoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GrayReleaseDemoAsyncHandler;
+			typedef Outcome<Error, Model::ListProductsByPopCodeResult> ListProductsByPopCodeOutcome;
+			typedef std::future<ListProductsByPopCodeOutcome> ListProductsByPopCodeOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::ListProductsByPopCodeRequest&, const ListProductsByPopCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListProductsByPopCodeAsyncHandler;
+			typedef Outcome<Error, Model::LjxTestResult> LjxTestOutcome;
+			typedef std::future<LjxTestOutcome> LjxTestOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::LjxTestRequest&, const LjxTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LjxTestAsyncHandler;
+			typedef Outcome<Error, Model::ReqBeanTestResult> ReqBeanTestOutcome;
+			typedef std::future<ReqBeanTestOutcome> ReqBeanTestOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::ReqBeanTestRequest&, const ReqBeanTestOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReqBeanTestAsyncHandler;
+			typedef Outcome<Error, Model::RomeGetExecutionResultResult> RomeGetExecutionResultOutcome;
+			typedef std::future<RomeGetExecutionResultOutcome> RomeGetExecutionResultOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::RomeGetExecutionResultRequest&, const RomeGetExecutionResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RomeGetExecutionResultAsyncHandler;
+			typedef Outcome<Error, Model::RpcHttpResult> RpcHttpOutcome;
+			typedef std::future<RpcHttpOutcome> RpcHttpOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::RpcHttpRequest&, const RpcHttpOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RpcHttpAsyncHandler;
+			typedef Outcome<Error, Model::TestPutApiAndGetApiResult> TestPutApiAndGetApiOutcome;
+			typedef std::future<TestPutApiAndGetApiOutcome> TestPutApiAndGetApiOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::TestPutApiAndGetApiRequest&, const TestPutApiAndGetApiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TestPutApiAndGetApiAsyncHandler;
+			typedef Outcome<Error, Model::UpdateListenerResult> UpdateListenerOutcome;
+			typedef std::future<UpdateListenerOutcome> UpdateListenerOutcomeCallable;
+			typedef std::function<void(const LmzTestClient*, const Model::UpdateListenerRequest&, const UpdateListenerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateListenerAsyncHandler;
+
+			LmzTestClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			LmzTestClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			LmzTestClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~LmzTestClient();
+			AAbckOutcome aAbck(const Model::AAbckRequest &request)const;
+			void aAbckAsync(const Model::AAbckRequest& request, const AAbckAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AAbckOutcomeCallable aAbckCallable(const Model::AAbckRequest& request) const;
+			AndBackOutcome andBack(const Model::AndBackRequest &request)const;
+			void andBackAsync(const Model::AndBackRequest& request, const AndBackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AndBackOutcomeCallable andBackCallable(const Model::AndBackRequest& request) const;
+			DataRateLimitTestOutcome dataRateLimitTest(const Model::DataRateLimitTestRequest &request)const;
+			void dataRateLimitTestAsync(const Model::DataRateLimitTestRequest& request, const DataRateLimitTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DataRateLimitTestOutcomeCallable dataRateLimitTestCallable(const Model::DataRateLimitTestRequest& request) const;
+			DemoGrayReleaseTestOutcome demoGrayReleaseTest(const Model::DemoGrayReleaseTestRequest &request)const;
+			void demoGrayReleaseTestAsync(const Model::DemoGrayReleaseTestRequest& request, const DemoGrayReleaseTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DemoGrayReleaseTestOutcomeCallable demoGrayReleaseTestCallable(const Model::DemoGrayReleaseTestRequest& request) const;
+			DemoGrayReleaseTestTwoOutcome demoGrayReleaseTestTwo(const Model::DemoGrayReleaseTestTwoRequest &request)const;
+			void demoGrayReleaseTestTwoAsync(const Model::DemoGrayReleaseTestTwoRequest& request, const DemoGrayReleaseTestTwoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DemoGrayReleaseTestTwoOutcomeCallable demoGrayReleaseTestTwoCallable(const Model::DemoGrayReleaseTestTwoRequest& request) const;
+			DemoGreyReleaseTestOutcome demoGreyReleaseTest(const Model::DemoGreyReleaseTestRequest &request)const;
+			void demoGreyReleaseTestAsync(const Model::DemoGreyReleaseTestRequest& request, const DemoGreyReleaseTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DemoGreyReleaseTestOutcomeCallable demoGreyReleaseTestCallable(const Model::DemoGreyReleaseTestRequest& request) const;
+			DemoHsfNineResponseOutcome demoHsfNineResponse(const Model::DemoHsfNineResponseRequest &request)const;
+			void demoHsfNineResponseAsync(const Model::DemoHsfNineResponseRequest& request, const DemoHsfNineResponseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DemoHsfNineResponseOutcomeCallable demoHsfNineResponseCallable(const Model::DemoHsfNineResponseRequest& request) const;
+			DemoHsfSixTestOutcome demoHsfSixTest(const Model::DemoHsfSixTestRequest &request)const;
+			void demoHsfSixTestAsync(const Model::DemoHsfSixTestRequest& request, const DemoHsfSixTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DemoHsfSixTestOutcomeCallable demoHsfSixTestCallable(const Model::DemoHsfSixTestRequest& request) const;
+			DemoHttpComplexResponseOutcome demoHttpComplexResponse(const Model::DemoHttpComplexResponseRequest &request)const;
+			void demoHttpComplexResponseAsync(const Model::DemoHttpComplexResponseRequest& request, const DemoHttpComplexResponseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DemoHttpComplexResponseOutcomeCallable demoHttpComplexResponseCallable(const Model::DemoHttpComplexResponseRequest& request) const;
+			DescribeDisksOutcome describeDisks(const Model::DescribeDisksRequest &request)const;
+			void describeDisksAsync(const Model::DescribeDisksRequest& request, const DescribeDisksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDisksOutcomeCallable describeDisksCallable(const Model::DescribeDisksRequest& request) const;
+			GetPackageStorageCredentialOutcome getPackageStorageCredential(const Model::GetPackageStorageCredentialRequest &request)const;
+			void getPackageStorageCredentialAsync(const Model::GetPackageStorageCredentialRequest& request, const GetPackageStorageCredentialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPackageStorageCredentialOutcomeCallable getPackageStorageCredentialCallable(const Model::GetPackageStorageCredentialRequest& request) const;
+			GrayReleaseDemoOutcome grayReleaseDemo(const Model::GrayReleaseDemoRequest &request)const;
+			void grayReleaseDemoAsync(const Model::GrayReleaseDemoRequest& request, const GrayReleaseDemoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GrayReleaseDemoOutcomeCallable grayReleaseDemoCallable(const Model::GrayReleaseDemoRequest& request) const;
+			ListProductsByPopCodeOutcome listProductsByPopCode(const Model::ListProductsByPopCodeRequest &request)const;
+			void listProductsByPopCodeAsync(const Model::ListProductsByPopCodeRequest& request, const ListProductsByPopCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListProductsByPopCodeOutcomeCallable listProductsByPopCodeCallable(const Model::ListProductsByPopCodeRequest& request) const;
+			LjxTestOutcome ljxTest(const Model::LjxTestRequest &request)const;
+			void ljxTestAsync(const Model::LjxTestRequest& request, const LjxTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			LjxTestOutcomeCallable ljxTestCallable(const Model::LjxTestRequest& request) const;
+			ReqBeanTestOutcome reqBeanTest(const Model::ReqBeanTestRequest &request)const;
+			void reqBeanTestAsync(const Model::ReqBeanTestRequest& request, const ReqBeanTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ReqBeanTestOutcomeCallable reqBeanTestCallable(const Model::ReqBeanTestRequest& request) const;
+			RomeGetExecutionResultOutcome romeGetExecutionResult(const Model::RomeGetExecutionResultRequest &request)const;
+			void romeGetExecutionResultAsync(const Model::RomeGetExecutionResultRequest& request, const RomeGetExecutionResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RomeGetExecutionResultOutcomeCallable romeGetExecutionResultCallable(const Model::RomeGetExecutionResultRequest& request) const;
+			RpcHttpOutcome rpcHttp(const Model::RpcHttpRequest &request)const;
+			void rpcHttpAsync(const Model::RpcHttpRequest& request, const RpcHttpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RpcHttpOutcomeCallable rpcHttpCallable(const Model::RpcHttpRequest& request) const;
+			TestPutApiAndGetApiOutcome testPutApiAndGetApi(const Model::TestPutApiAndGetApiRequest &request)const;
+			void testPutApiAndGetApiAsync(const Model::TestPutApiAndGetApiRequest& request, const TestPutApiAndGetApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TestPutApiAndGetApiOutcomeCallable testPutApiAndGetApiCallable(const Model::TestPutApiAndGetApiRequest& request) const;
+			UpdateListenerOutcome updateListener(const Model::UpdateListenerRequest &request)const;
+			void updateListenerAsync(const Model::UpdateListenerRequest& request, const UpdateListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateListenerOutcomeCallable updateListenerCallable(const Model::UpdateListenerRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_LMZTEST_LMZTESTCLIENT_H_

lmztest/include/alibabacloud/lmztest/LmzTestExport.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_LMZTEST_LMZTESTEXPORT_H_
+#define ALIBABACLOUD_LMZTEST_LMZTESTEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_LMZTEST_LIBRARY)
+#		define ALIBABACLOUD_LMZTEST_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_LMZTEST_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_LMZTEST_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_LMZTEST_LMZTESTEXPORT_H_

lmztest/include/alibabacloud/lmztest/model/AAbckRequest.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_LMZTEST_MODEL_AABCKREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_AABCKREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT AAbckRequest : public RpcServiceRequest {
+public:
+	AAbckRequest();
+	~AAbckRequest();
+	std::string getClientToken3() const;
+	void setClientToken3(const std::string &clientToken3);
+	std::string getTestDemo() const;
+	void setTestDemo(const std::string &testDemo);
+
+private:
+	std::string clientToken3_;
+	std::string testDemo_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_AABCKREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/AAbckResult.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_LMZTEST_MODEL_AABCKRESULT_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_AABCKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/lmztest/LmzTestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace LmzTest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LMZTEST_EXPORT AAbckResult : public ServiceResult
+			{
+			public:
+
+
+				AAbckResult();
+				explicit AAbckResult(const std::string &payload);
+				~AAbckResult();
+				std::string getId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string id_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_AABCKRESULT_H_

lmztest/include/alibabacloud/lmztest/model/AndBackRequest.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_LMZTEST_MODEL_ANDBACKREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_ANDBACKREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT AndBackRequest : public RpcServiceRequest {
+public:
+	AndBackRequest();
+	~AndBackRequest();
+	std::string getClientToken2() const;
+	void setClientToken2(const std::string &clientToken2);
+	std::string getTestDemo() const;
+	void setTestDemo(const std::string &testDemo);
+
+private:
+	std::string clientToken2_;
+	std::string testDemo_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_ANDBACKREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/AndBackResult.h

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

lmztest/include/alibabacloud/lmztest/model/DataRateLimitTestRequest.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_LMZTEST_MODEL_DATARATELIMITTESTREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_DATARATELIMITTESTREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT DataRateLimitTestRequest : public RpcServiceRequest {
+public:
+	DataRateLimitTestRequest();
+	~DataRateLimitTestRequest();
+
+private:
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_DATARATELIMITTESTREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/DataRateLimitTestResult.h

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

lmztest/include/alibabacloud/lmztest/model/DemoGrayReleaseTestRequest.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_LMZTEST_MODEL_DEMOGRAYRELEASETESTREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT DemoGrayReleaseTestRequest : public RpcServiceRequest {
+public:
+	DemoGrayReleaseTestRequest();
+	~DemoGrayReleaseTestRequest();
+	int getNumberCode() const;
+	void setNumberCode(int numberCode);
+	std::string getId() const;
+	void setId(const std::string &id);
+
+private:
+	int numberCode_;
+	std::string id_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/DemoGrayReleaseTestResult.h

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

lmztest/include/alibabacloud/lmztest/model/DemoGrayReleaseTestTwoRequest.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_LMZTEST_MODEL_DEMOGRAYRELEASETESTTWOREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTTWOREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT DemoGrayReleaseTestTwoRequest : public RpcServiceRequest {
+public:
+	DemoGrayReleaseTestTwoRequest();
+	~DemoGrayReleaseTestTwoRequest();
+	std::string getNumberCode() const;
+	void setNumberCode(const std::string &numberCode);
+	long getCode() const;
+	void setCode(long code);
+
+private:
+	std::string numberCode_;
+	long code_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOGRAYRELEASETESTTWOREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/DemoGrayReleaseTestTwoResult.h

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

lmztest/include/alibabacloud/lmztest/model/DemoGreyReleaseTestRequest.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_LMZTEST_MODEL_DEMOGREYRELEASETESTREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_DEMOGREYRELEASETESTREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT DemoGreyReleaseTestRequest : public RpcServiceRequest {
+public:
+	DemoGreyReleaseTestRequest();
+	~DemoGreyReleaseTestRequest();
+	long getNumber() const;
+	void setNumber(long number);
+
+private:
+	long number_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOGREYRELEASETESTREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/DemoGreyReleaseTestResult.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_LMZTEST_MODEL_DEMOGREYRELEASETESTRESULT_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_DEMOGREYRELEASETESTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/lmztest/LmzTestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace LmzTest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LMZTEST_EXPORT DemoGreyReleaseTestResult : public ServiceResult
+			{
+			public:
+
+
+				DemoGreyReleaseTestResult();
+				explicit DemoGreyReleaseTestResult(const std::string &payload);
+				~DemoGreyReleaseTestResult();
+				std::string getId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string id_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOGREYRELEASETESTRESULT_H_

lmztest/include/alibabacloud/lmztest/model/DemoHsfNineResponseRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFNINERESPONSEREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFNINERESPONSEREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT DemoHsfNineResponseRequest : public RpcServiceRequest {
+public:
+	struct UserMap {
+		std::string uaa;
+		std::string uas;
+		std::string name;
+		std::string id;
+	};
+	DemoHsfNineResponseRequest();
+	~DemoHsfNineResponseRequest();
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getTestF1() const;
+	void setTestF1(const std::string &testF1);
+	std::map<std::string, userMap> getUserMap() const;
+	void setUserMap(const std::map<std::string, userMap> &userMap);
+
+private:
+	std::string name_;
+	std::string testF1_;
+	std::map<std::string, userMap> userMap_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFNINERESPONSEREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/DemoHsfNineResponseResult.h

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

lmztest/include/alibabacloud/lmztest/model/DemoHsfSixTestRequest.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFSIXTESTREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFSIXTESTREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT DemoHsfSixTestRequest : public RpcServiceRequest {
+public:
+	struct CodeMap {
+		std::string name;
+		std::string id;
+	};
+	DemoHsfSixTestRequest();
+	~DemoHsfSixTestRequest();
+	std::vector<std::map<std::string, std::map<std::string, ObjectOfAny>>> getStrListMap() const;
+	void setStrListMap(const std::vector<std::map<std::string, std::map<std::string, ObjectOfAny>>> &strListMap);
+	std::string getData() const;
+	void setData(const std::string &data);
+	std::string getMap() const;
+	void setMap(const std::string &map);
+	std::map<std::string, codeMap> getCodeMap() const;
+	void setCodeMap(const std::map<std::string, codeMap> &codeMap);
+
+private:
+	std::vector<std::map<std::string, std::map<std::string, ObjectOfAny>>> strListMap_;
+	std::string data_;
+	std::string map_;
+	std::map<std::string, codeMap> codeMap_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFSIXTESTREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/DemoHsfSixTestResult.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_LMZTEST_MODEL_DEMOHSFSIXTESTRESULT_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFSIXTESTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/lmztest/LmzTestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace LmzTest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LMZTEST_EXPORT DemoHsfSixTestResult : public ServiceResult
+			{
+			public:
+
+
+				DemoHsfSixTestResult();
+				explicit DemoHsfSixTestResult(const std::string &payload);
+				~DemoHsfSixTestResult();
+				std::vector<std::string> getData()const;
+				std::string getId()const;
+				std::string getCode()const;
+				std::string getName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> data_;
+				std::string id_;
+				std::string code_;
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOHSFSIXTESTRESULT_H_

lmztest/include/alibabacloud/lmztest/model/DemoHttpComplexResponseRequest.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_LMZTEST_MODEL_DEMOHTTPCOMPLEXRESPONSEREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_DEMOHTTPCOMPLEXRESPONSEREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT DemoHttpComplexResponseRequest : public RpcServiceRequest {
+public:
+	DemoHttpComplexResponseRequest();
+	~DemoHttpComplexResponseRequest();
+	std::string getReqInfo() const;
+	void setReqInfo(const std::string &reqInfo);
+
+private:
+	std::string reqInfo_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_DEMOHTTPCOMPLEXRESPONSEREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/DemoHttpComplexResponseResult.h

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

lmztest/include/alibabacloud/lmztest/model/DescribeDisksRequest.h

@@ -0,0 +1,154 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_LMZTEST_MODEL_DESCRIBEDISKSREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_DESCRIBEDISKSREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT DescribeDisksRequest : public RpcServiceRequest {
+public:
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	DescribeDisksRequest();
+	~DescribeDisksRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getFilter2Value() const;
+	void setFilter2Value(const std::string &filter2Value);
+	std::string getAutoSnapshotPolicyId() const;
+	void setAutoSnapshotPolicyId(const std::string &autoSnapshotPolicyId);
+	std::string getDiskName() const;
+	void setDiskName(const std::string &diskName);
+	bool getDeleteAutoSnapshot() const;
+	void setDeleteAutoSnapshot(bool deleteAutoSnapshot);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getDiskChargeType() const;
+	void setDiskChargeType(const std::string &diskChargeType);
+	std::string getLockReason() const;
+	void setLockReason(const std::string &lockReason);
+	std::string getFilter1Key() const;
+	void setFilter1Key(const std::string &filter1Key);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	bool getEnableAutoSnapshot() const;
+	void setEnableAutoSnapshot(bool enableAutoSnapshot);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getFilter1Value() const;
+	void setFilter1Value(const std::string &filter1Value);
+	bool getPortable() const;
+	void setPortable(bool portable);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::vector<std::string> getAdditionalAttributes() const;
+	void setAdditionalAttributes(const std::vector<std::string> &additionalAttributes);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+	std::string getSnapshotId() const;
+	void setSnapshotId(const std::string &snapshotId);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getDiskIds() const;
+	void setDiskIds(const std::string &diskIds);
+	std::string getMultiAttach() const;
+	void setMultiAttach(const std::string &multiAttach);
+	bool getDeleteWithInstance() const;
+	void setDeleteWithInstance(bool deleteWithInstance);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	bool getEnableAutomatedSnapshotPolicy() const;
+	void setEnableAutomatedSnapshotPolicy(bool enableAutomatedSnapshotPolicy);
+	std::string getFilter2Key() const;
+	void setFilter2Key(const std::string &filter2Key);
+	std::string getDiskType() const;
+	void setDiskType(const std::string &diskType);
+	bool getEnableShared() const;
+	void setEnableShared(bool enableShared);
+	bool getEncrypted() const;
+	void setEncrypted(bool encrypted);
+	std::string getCategory() const;
+	void setCategory(const std::string &category);
+	std::string getKMSKeyId() const;
+	void setKMSKeyId(const std::string &kMSKeyId);
+
+private:
+	long resourceOwnerId_;
+	std::string filter2Value_;
+	std::string autoSnapshotPolicyId_;
+	std::string diskName_;
+	bool deleteAutoSnapshot_;
+	std::string resourceGroupId_;
+	std::string diskChargeType_;
+	std::string lockReason_;
+	std::string filter1Key_;
+	std::vector<Tag> tag_;
+	bool enableAutoSnapshot_;
+	bool dryRun_;
+	std::string filter1Value_;
+	bool portable_;
+	long ownerId_;
+	std::vector<std::string> additionalAttributes_;
+	std::string instanceId_;
+	std::string zoneId_;
+	int maxResults_;
+	std::string status_;
+	std::string snapshotId_;
+	int pageNumber_;
+	std::string regionId_;
+	std::string nextToken_;
+	int pageSize_;
+	std::string diskIds_;
+	std::string multiAttach_;
+	bool deleteWithInstance_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	bool enableAutomatedSnapshotPolicy_;
+	std::string filter2Key_;
+	std::string diskType_;
+	bool enableShared_;
+	bool encrypted_;
+	std::string category_;
+	std::string kMSKeyId_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_DESCRIBEDISKSREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/DescribeDisksResult.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LMZTEST_MODEL_DESCRIBEDISKSRESULT_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_DESCRIBEDISKSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/lmztest/LmzTestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace LmzTest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LMZTEST_EXPORT DescribeDisksResult : public ServiceResult
+			{
+			public:
+				struct Disk
+				{
+					struct OperationLock
+					{
+						std::string lockReason;
+					};
+					struct MountInstance
+					{
+						std::string attachedTime;
+						std::string instanceId;
+						std::string device;
+					};
+					struct Tag
+					{
+						std::string tagKey;
+						std::string tagValue;
+					};
+					struct Attachment
+					{
+						std::string attachedTime;
+						std::string instanceId;
+						std::string device;
+					};
+					std::string detachedTime;
+					std::string description;
+					std::string kMSKeyId;
+					std::string category;
+					std::string resourceGroupId;
+					std::string dedicatedBlockStorageClusterId;
+					bool encrypted;
+					int size;
+					bool deleteAutoSnapshot;
+					std::string diskChargeType;
+					int storageSetPartitionNumber;
+					int iOPS;
+					std::vector<Disk::Attachment> attachments;
+					std::string multiAttach;
+					std::string expiredTime;
+					std::string imageId;
+					std::string storageSetId;
+					std::vector<Disk::Tag> tags;
+					std::string status;
+					int iOPSRead;
+					std::string attachedTime;
+					int iOPSWrite;
+					std::string zoneId;
+					std::string sourceSnapshotId;
+					std::string instanceId;
+					std::string productCode;
+					std::string performanceLevel;
+					std::string device;
+					bool deleteWithInstance;
+					bool enableAutomatedSnapshotPolicy;
+					bool enableAutoSnapshot;
+					std::string autoSnapshotPolicyId;
+					std::string diskName;
+					std::vector<Disk::OperationLock> operationLocks;
+					std::string bdfId;
+					bool portable;
+					std::string type;
+					int mountInstanceNum;
+					std::string serialNumber;
+					std::vector<Disk::MountInstance> mountInstances;
+					std::string creationTime;
+					std::string regionId;
+					std::string diskId;
+				};
+
+
+				DescribeDisksResult();
+				explicit DescribeDisksResult(const std::string &payload);
+				~DescribeDisksResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<Disk> getDisks()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<Disk> disks_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_DESCRIBEDISKSRESULT_H_

lmztest/include/alibabacloud/lmztest/model/GetPackageStorageCredentialRequest.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_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT GetPackageStorageCredentialRequest : public RpcServiceRequest {
+public:
+	GetPackageStorageCredentialRequest();
+	~GetPackageStorageCredentialRequest();
+
+private:
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/GetPackageStorageCredentialResult.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_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALRESULT_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/lmztest/LmzTestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace LmzTest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LMZTEST_EXPORT GetPackageStorageCredentialResult : public ServiceResult
+			{
+			public:
+				struct Credential
+				{
+					std::string securityToken;
+					std::string ossInternalEndpoint;
+					std::string bucket;
+					std::string ossPublicEndpoint;
+					std::string accessKeyId;
+					std::string accessKeySecret;
+					std::string ossVpcEndpoint;
+					std::string expiration;
+					std::string regionId;
+					std::string keyPrefix;
+				};
+
+
+				GetPackageStorageCredentialResult();
+				explicit GetPackageStorageCredentialResult(const std::string &payload);
+				~GetPackageStorageCredentialResult();
+				Credential getCredential()const;
+				std::string getMessage()const;
+				int getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Credential credential_;
+				std::string message_;
+				int code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_GETPACKAGESTORAGECREDENTIALRESULT_H_

lmztest/include/alibabacloud/lmztest/model/GrayReleaseDemoRequest.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_LMZTEST_MODEL_GRAYRELEASEDEMOREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_GRAYRELEASEDEMOREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT GrayReleaseDemoRequest : public RpcServiceRequest {
+public:
+	GrayReleaseDemoRequest();
+	~GrayReleaseDemoRequest();
+	std::string getId() const;
+	void setId(const std::string &id);
+
+private:
+	std::string id_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_GRAYRELEASEDEMOREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/GrayReleaseDemoResult.h

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

lmztest/include/alibabacloud/lmztest/model/ListProductsByPopCodeRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODEREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODEREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT ListProductsByPopCodeRequest : public RpcServiceRequest {
+public:
+	ListProductsByPopCodeRequest();
+	~ListProductsByPopCodeRequest();
+	std::string getAuthKey() const;
+	void setAuthKey(const std::string &authKey);
+	std::string getExtraParams() const;
+	void setExtraParams(const std::string &extraParams);
+	std::string getServerClientIp() const;
+	void setServerClientIp(const std::string &serverClientIp);
+	std::string getRequestId() const;
+	void setRequestId(const std::string &requestId);
+	std::string getClientIp() const;
+	void setClientIp(const std::string &clientIp);
+	std::string getIdentityDTO() const;
+	void setIdentityDTO(const std::string &identityDTO);
+	std::string getEnv() const;
+	void setEnv(const std::string &env);
+	std::string getPopCode() const;
+	void setPopCode(const std::string &popCode);
+
+private:
+	std::string authKey_;
+	std::string extraParams_;
+	std::string serverClientIp_;
+	std::string requestId_;
+	std::string clientIp_;
+	std::string identityDTO_;
+	std::string env_;
+	std::string popCode_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODEREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/ListProductsByPopCodeResult.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODERESULT_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/lmztest/LmzTestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace LmzTest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LMZTEST_EXPORT ListProductsByPopCodeResult : public ServiceResult
+			{
+			public:
+				struct ResultItem
+				{
+					struct UniqueKeyDTO
+					{
+						std::string namespaceCode;
+					};
+					struct NameSpaceExtDTO
+					{
+						struct BusinessOwnerListItem
+						{
+							std::string bucId;
+							std::string id;
+							std::string name;
+						};
+						struct TechniqueOwnerListItem
+						{
+							std::string bucId;
+							std::string id;
+							std::string name;
+						};
+						std::vector<BusinessOwnerListItem> businessOwnerList;
+						std::vector<TechniqueOwnerListItem> techniqueOwnerList;
+					};
+					UniqueKeyDTO uniqueKeyDTO;
+					NameSpaceExtDTO nameSpaceExtDTO;
+				};
+
+
+				ListProductsByPopCodeResult();
+				explicit ListProductsByPopCodeResult(const std::string &payload);
+				~ListProductsByPopCodeResult();
+				std::string getErrorDetailMessage()const;
+				std::string getTraceId()const;
+				std::string getErrorCode()const;
+				std::string getErrorMessage()const;
+				bool getSuccess()const;
+				std::vector<ResultItem> getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string errorDetailMessage_;
+				std::string traceId_;
+				std::string errorCode_;
+				std::string errorMessage_;
+				bool success_;
+				std::vector<ResultItem> result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_LISTPRODUCTSBYPOPCODERESULT_H_

lmztest/include/alibabacloud/lmztest/model/LjxTestRequest.h

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LMZTEST_MODEL_LJXTESTREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_LJXTESTREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT LjxTestRequest : public RpcServiceRequest {
+public:
+	LjxTestRequest();
+	~LjxTestRequest();
+	std::string getNewparam2() const;
+	void setNewparam2(const std::string &newparam2);
+	std::vector<std::string> getNewparam1() const;
+	void setNewparam1(const std::vector<std::string> &newparam1);
+	std::map<std::string, std::string> getCode() const;
+	void setCode(const std::map<std::string, std::string> &code);
+	std::string getId() const;
+	void setId(const std::string &id);
+	std::string getBody() const;
+	void setBody(const std::string &body);
+
+private:
+	std::string newparam2_;
+	std::vector<std::string> newparam1_;
+	std::map<std::string, std::string> code_;
+	std::string id_;
+	std::string body_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_LJXTESTREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/LjxTestResult.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_LMZTEST_MODEL_LJXTESTRESULT_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_LJXTESTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/lmztest/LmzTestExport.h>
+
+namespace AlibabaCloud
+{
+	namespace LmzTest
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_LMZTEST_EXPORT LjxTestResult : public ServiceResult
+			{
+			public:
+				struct Testtest
+				{
+					std::string id;
+				};
+				struct MapsItem
+				{
+					std::string param0;
+				};
+
+
+				LjxTestResult();
+				explicit LjxTestResult(const std::string &payload);
+				~LjxTestResult();
+				std::vector<MapsItem> getMaps()const;
+				std::vector<std::string> getStringList()const;
+				Testtest getTesttest()const;
+				std::vector<std::string> getLongList()const;
+				std::string getId()const;
+				int getCode()const;
+				std::string getName()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<MapsItem> maps_;
+				std::vector<std::string> stringList_;
+				Testtest testtest_;
+				std::vector<std::string> longList_;
+				std::string id_;
+				int code_;
+				std::string name_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_LJXTESTRESULT_H_

lmztest/include/alibabacloud/lmztest/model/ReqBeanTestRequest.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LMZTEST_MODEL_REQBEANTESTREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_REQBEANTESTREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT ReqBeanTestRequest : public RpcServiceRequest {
+public:
+	struct Users {
+		std::string name;
+		std::string id;
+	};
+	ReqBeanTestRequest();
+	~ReqBeanTestRequest();
+	std::vector<std::string> getCodes() const;
+	void setCodes(const std::vector<std::string> &codes);
+	std::string getXhostheadertest() const;
+	void setXhostheadertest(const std::string &xhostheadertest);
+	std::string getId() const;
+	void setId(const std::string &id);
+	std::vector<long> getNums() const;
+	void setNums(const std::vector<long> &nums);
+	std::vector<users> getUsers() const;
+	void setUsers(const std::vector<users> &users);
+
+private:
+	std::vector<std::string> codes_;
+	std::string xhostheadertest_;
+	std::string id_;
+	std::vector<long> nums_;
+	std::vector<users> users_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_REQBEANTESTREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/ReqBeanTestResult.h

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

lmztest/include/alibabacloud/lmztest/model/RomeGetExecutionResultRequest.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_LMZTEST_MODEL_ROMEGETEXECUTIONRESULTREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_ROMEGETEXECUTIONRESULTREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT RomeGetExecutionResultRequest : public RpcServiceRequest {
+public:
+	RomeGetExecutionResultRequest();
+	~RomeGetExecutionResultRequest();
+	std::string getFlowRequestId() const;
+	void setFlowRequestId(const std::string &flowRequestId);
+
+private:
+	std::string flowRequestId_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_ROMEGETEXECUTIONRESULTREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/RomeGetExecutionResultResult.h

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

lmztest/include/alibabacloud/lmztest/model/RpcHttpRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LMZTEST_MODEL_RPCHTTPREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_RPCHTTPREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT RpcHttpRequest : public RpcServiceRequest {
+public:
+	RpcHttpRequest();
+	~RpcHttpRequest();
+	std::string getNews() const;
+	void setNews(const std::string &news);
+	std::string getCodes() const;
+	void setCodes(const std::string &codes);
+	std::string getNumber() const;
+	void setNumber(const std::string &number);
+	std::string getMonkey() const;
+	void setMonkey(const std::string &monkey);
+	std::string getWorld() const;
+	void setWorld(const std::string &world);
+	std::string getParam() const;
+	void setParam(const std::string &param);
+	std::string getOld() const;
+	void setOld(const std::string &old);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getId() const;
+	void setId(const std::string &id);
+	std::string getNone() const;
+	void setNone(const std::string &none);
+
+private:
+	std::string news_;
+	std::string codes_;
+	std::string number_;
+	std::string monkey_;
+	std::string world_;
+	std::string param_;
+	std::string old_;
+	std::string name_;
+	std::string id_;
+	std::string none_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_RPCHTTPREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/RpcHttpResult.h

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

lmztest/include/alibabacloud/lmztest/model/TestPutApiAndGetApiRequest.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_LMZTEST_MODEL_TESTPUTAPIANDGETAPIREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_TESTPUTAPIANDGETAPIREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT TestPutApiAndGetApiRequest : public RpcServiceRequest {
+public:
+	TestPutApiAndGetApiRequest();
+	~TestPutApiAndGetApiRequest();
+
+private:
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_TESTPUTAPIANDGETAPIREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/TestPutApiAndGetApiResult.h

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

lmztest/include/alibabacloud/lmztest/model/UpdateListenerRequest.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_LMZTEST_MODEL_UPDATELISTENERREQUEST_H_
+#define ALIBABACLOUD_LMZTEST_MODEL_UPDATELISTENERREQUEST_H_
+
+#include <alibabacloud/lmztest/LmzTestExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace LmzTest {
+namespace Model {
+class ALIBABACLOUD_LMZTEST_EXPORT UpdateListenerRequest : public RpcServiceRequest {
+public:
+	struct BackendPorts {
+		int fromPort;
+		int toPort;
+	};
+	struct PortRanges {
+		int fromPort;
+		int toPort;
+	};
+	struct Certificates {
+		std::string id;
+	};
+	UpdateListenerRequest();
+	~UpdateListenerRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::vector<BackendPorts> getBackendPorts() const;
+	void setBackendPorts(const std::vector<BackendPorts> &backendPorts);
+	std::string getListenerId() const;
+	void setListenerId(const std::string &listenerId);
+	std::string getProtocol() const;
+	void setProtocol(const std::string &protocol);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getProxyProtocol() const;
+	void setProxyProtocol(const std::string &proxyProtocol);
+	std::vector<PortRanges> getPortRanges() const;
+	void setPortRanges(const std::vector<PortRanges> &portRanges);
+	std::vector<Certificates> getCertificates() const;
+	void setCertificates(const std::vector<Certificates> &certificates);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getClientAffinity() const;
+	void setClientAffinity(const std::string &clientAffinity);
+
+private:
+	std::string clientToken_;
+	std::string description_;
+	std::vector<BackendPorts> backendPorts_;
+	std::string listenerId_;
+	std::string protocol_;
+	std::string regionId_;
+	std::string proxyProtocol_;
+	std::vector<PortRanges> portRanges_;
+	std::vector<Certificates> certificates_;
+	std::string name_;
+	std::string clientAffinity_;
+};
+} // namespace Model
+} // namespace LmzTest
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_LMZTEST_MODEL_UPDATELISTENERREQUEST_H_

lmztest/include/alibabacloud/lmztest/model/UpdateListenerResult.h

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

lmztest/src/LmzTestClient.cc

@@ -0,0 +1,737 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/lmztest/LmzTestClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::LmzTest;
+using namespace AlibabaCloud::LmzTest::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "LmzTest";
+}
+
+LmzTestClient::LmzTestClient(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, "");
+}
+
+LmzTestClient::LmzTestClient(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, "");
+}
+
+LmzTestClient::LmzTestClient(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, "");
+}
+
+LmzTestClient::~LmzTestClient()
+{}
+
+LmzTestClient::AAbckOutcome LmzTestClient::aAbck(const AAbckRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AAbckOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AAbckOutcome(AAbckResult(outcome.result()));
+	else
+		return AAbckOutcome(outcome.error());
+}
+
+void LmzTestClient::aAbckAsync(const AAbckRequest& request, const AAbckAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, aAbck(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::AAbckOutcomeCallable LmzTestClient::aAbckCallable(const AAbckRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AAbckOutcome()>>(
+			[this, request]()
+			{
+			return this->aAbck(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::AndBackOutcome LmzTestClient::andBack(const AndBackRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AndBackOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AndBackOutcome(AndBackResult(outcome.result()));
+	else
+		return AndBackOutcome(outcome.error());
+}
+
+void LmzTestClient::andBackAsync(const AndBackRequest& request, const AndBackAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, andBack(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::AndBackOutcomeCallable LmzTestClient::andBackCallable(const AndBackRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AndBackOutcome()>>(
+			[this, request]()
+			{
+			return this->andBack(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::DataRateLimitTestOutcome LmzTestClient::dataRateLimitTest(const DataRateLimitTestRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DataRateLimitTestOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DataRateLimitTestOutcome(DataRateLimitTestResult(outcome.result()));
+	else
+		return DataRateLimitTestOutcome(outcome.error());
+}
+
+void LmzTestClient::dataRateLimitTestAsync(const DataRateLimitTestRequest& request, const DataRateLimitTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, dataRateLimitTest(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::DataRateLimitTestOutcomeCallable LmzTestClient::dataRateLimitTestCallable(const DataRateLimitTestRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DataRateLimitTestOutcome()>>(
+			[this, request]()
+			{
+			return this->dataRateLimitTest(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::DemoGrayReleaseTestOutcome LmzTestClient::demoGrayReleaseTest(const DemoGrayReleaseTestRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DemoGrayReleaseTestOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DemoGrayReleaseTestOutcome(DemoGrayReleaseTestResult(outcome.result()));
+	else
+		return DemoGrayReleaseTestOutcome(outcome.error());
+}
+
+void LmzTestClient::demoGrayReleaseTestAsync(const DemoGrayReleaseTestRequest& request, const DemoGrayReleaseTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, demoGrayReleaseTest(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::DemoGrayReleaseTestOutcomeCallable LmzTestClient::demoGrayReleaseTestCallable(const DemoGrayReleaseTestRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DemoGrayReleaseTestOutcome()>>(
+			[this, request]()
+			{
+			return this->demoGrayReleaseTest(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::DemoGrayReleaseTestTwoOutcome LmzTestClient::demoGrayReleaseTestTwo(const DemoGrayReleaseTestTwoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DemoGrayReleaseTestTwoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DemoGrayReleaseTestTwoOutcome(DemoGrayReleaseTestTwoResult(outcome.result()));
+	else
+		return DemoGrayReleaseTestTwoOutcome(outcome.error());
+}
+
+void LmzTestClient::demoGrayReleaseTestTwoAsync(const DemoGrayReleaseTestTwoRequest& request, const DemoGrayReleaseTestTwoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, demoGrayReleaseTestTwo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::DemoGrayReleaseTestTwoOutcomeCallable LmzTestClient::demoGrayReleaseTestTwoCallable(const DemoGrayReleaseTestTwoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DemoGrayReleaseTestTwoOutcome()>>(
+			[this, request]()
+			{
+			return this->demoGrayReleaseTestTwo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::DemoGreyReleaseTestOutcome LmzTestClient::demoGreyReleaseTest(const DemoGreyReleaseTestRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DemoGreyReleaseTestOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DemoGreyReleaseTestOutcome(DemoGreyReleaseTestResult(outcome.result()));
+	else
+		return DemoGreyReleaseTestOutcome(outcome.error());
+}
+
+void LmzTestClient::demoGreyReleaseTestAsync(const DemoGreyReleaseTestRequest& request, const DemoGreyReleaseTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, demoGreyReleaseTest(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::DemoGreyReleaseTestOutcomeCallable LmzTestClient::demoGreyReleaseTestCallable(const DemoGreyReleaseTestRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DemoGreyReleaseTestOutcome()>>(
+			[this, request]()
+			{
+			return this->demoGreyReleaseTest(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::DemoHsfNineResponseOutcome LmzTestClient::demoHsfNineResponse(const DemoHsfNineResponseRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DemoHsfNineResponseOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DemoHsfNineResponseOutcome(DemoHsfNineResponseResult(outcome.result()));
+	else
+		return DemoHsfNineResponseOutcome(outcome.error());
+}
+
+void LmzTestClient::demoHsfNineResponseAsync(const DemoHsfNineResponseRequest& request, const DemoHsfNineResponseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, demoHsfNineResponse(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::DemoHsfNineResponseOutcomeCallable LmzTestClient::demoHsfNineResponseCallable(const DemoHsfNineResponseRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DemoHsfNineResponseOutcome()>>(
+			[this, request]()
+			{
+			return this->demoHsfNineResponse(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::DemoHsfSixTestOutcome LmzTestClient::demoHsfSixTest(const DemoHsfSixTestRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DemoHsfSixTestOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DemoHsfSixTestOutcome(DemoHsfSixTestResult(outcome.result()));
+	else
+		return DemoHsfSixTestOutcome(outcome.error());
+}
+
+void LmzTestClient::demoHsfSixTestAsync(const DemoHsfSixTestRequest& request, const DemoHsfSixTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, demoHsfSixTest(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::DemoHsfSixTestOutcomeCallable LmzTestClient::demoHsfSixTestCallable(const DemoHsfSixTestRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DemoHsfSixTestOutcome()>>(
+			[this, request]()
+			{
+			return this->demoHsfSixTest(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::DemoHttpComplexResponseOutcome LmzTestClient::demoHttpComplexResponse(const DemoHttpComplexResponseRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DemoHttpComplexResponseOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DemoHttpComplexResponseOutcome(DemoHttpComplexResponseResult(outcome.result()));
+	else
+		return DemoHttpComplexResponseOutcome(outcome.error());
+}
+
+void LmzTestClient::demoHttpComplexResponseAsync(const DemoHttpComplexResponseRequest& request, const DemoHttpComplexResponseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, demoHttpComplexResponse(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::DemoHttpComplexResponseOutcomeCallable LmzTestClient::demoHttpComplexResponseCallable(const DemoHttpComplexResponseRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DemoHttpComplexResponseOutcome()>>(
+			[this, request]()
+			{
+			return this->demoHttpComplexResponse(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::DescribeDisksOutcome LmzTestClient::describeDisks(const DescribeDisksRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDisksOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDisksOutcome(DescribeDisksResult(outcome.result()));
+	else
+		return DescribeDisksOutcome(outcome.error());
+}
+
+void LmzTestClient::describeDisksAsync(const DescribeDisksRequest& request, const DescribeDisksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDisks(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::DescribeDisksOutcomeCallable LmzTestClient::describeDisksCallable(const DescribeDisksRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDisksOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDisks(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::GetPackageStorageCredentialOutcome LmzTestClient::getPackageStorageCredential(const GetPackageStorageCredentialRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetPackageStorageCredentialOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetPackageStorageCredentialOutcome(GetPackageStorageCredentialResult(outcome.result()));
+	else
+		return GetPackageStorageCredentialOutcome(outcome.error());
+}
+
+void LmzTestClient::getPackageStorageCredentialAsync(const GetPackageStorageCredentialRequest& request, const GetPackageStorageCredentialAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getPackageStorageCredential(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::GetPackageStorageCredentialOutcomeCallable LmzTestClient::getPackageStorageCredentialCallable(const GetPackageStorageCredentialRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetPackageStorageCredentialOutcome()>>(
+			[this, request]()
+			{
+			return this->getPackageStorageCredential(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::GrayReleaseDemoOutcome LmzTestClient::grayReleaseDemo(const GrayReleaseDemoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GrayReleaseDemoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GrayReleaseDemoOutcome(GrayReleaseDemoResult(outcome.result()));
+	else
+		return GrayReleaseDemoOutcome(outcome.error());
+}
+
+void LmzTestClient::grayReleaseDemoAsync(const GrayReleaseDemoRequest& request, const GrayReleaseDemoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, grayReleaseDemo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::GrayReleaseDemoOutcomeCallable LmzTestClient::grayReleaseDemoCallable(const GrayReleaseDemoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GrayReleaseDemoOutcome()>>(
+			[this, request]()
+			{
+			return this->grayReleaseDemo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::ListProductsByPopCodeOutcome LmzTestClient::listProductsByPopCode(const ListProductsByPopCodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListProductsByPopCodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListProductsByPopCodeOutcome(ListProductsByPopCodeResult(outcome.result()));
+	else
+		return ListProductsByPopCodeOutcome(outcome.error());
+}
+
+void LmzTestClient::listProductsByPopCodeAsync(const ListProductsByPopCodeRequest& request, const ListProductsByPopCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listProductsByPopCode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::ListProductsByPopCodeOutcomeCallable LmzTestClient::listProductsByPopCodeCallable(const ListProductsByPopCodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListProductsByPopCodeOutcome()>>(
+			[this, request]()
+			{
+			return this->listProductsByPopCode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::LjxTestOutcome LmzTestClient::ljxTest(const LjxTestRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return LjxTestOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return LjxTestOutcome(LjxTestResult(outcome.result()));
+	else
+		return LjxTestOutcome(outcome.error());
+}
+
+void LmzTestClient::ljxTestAsync(const LjxTestRequest& request, const LjxTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, ljxTest(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::LjxTestOutcomeCallable LmzTestClient::ljxTestCallable(const LjxTestRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<LjxTestOutcome()>>(
+			[this, request]()
+			{
+			return this->ljxTest(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::ReqBeanTestOutcome LmzTestClient::reqBeanTest(const ReqBeanTestRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ReqBeanTestOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ReqBeanTestOutcome(ReqBeanTestResult(outcome.result()));
+	else
+		return ReqBeanTestOutcome(outcome.error());
+}
+
+void LmzTestClient::reqBeanTestAsync(const ReqBeanTestRequest& request, const ReqBeanTestAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, reqBeanTest(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::ReqBeanTestOutcomeCallable LmzTestClient::reqBeanTestCallable(const ReqBeanTestRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ReqBeanTestOutcome()>>(
+			[this, request]()
+			{
+			return this->reqBeanTest(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::RomeGetExecutionResultOutcome LmzTestClient::romeGetExecutionResult(const RomeGetExecutionResultRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RomeGetExecutionResultOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RomeGetExecutionResultOutcome(RomeGetExecutionResultResult(outcome.result()));
+	else
+		return RomeGetExecutionResultOutcome(outcome.error());
+}
+
+void LmzTestClient::romeGetExecutionResultAsync(const RomeGetExecutionResultRequest& request, const RomeGetExecutionResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, romeGetExecutionResult(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::RomeGetExecutionResultOutcomeCallable LmzTestClient::romeGetExecutionResultCallable(const RomeGetExecutionResultRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RomeGetExecutionResultOutcome()>>(
+			[this, request]()
+			{
+			return this->romeGetExecutionResult(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::RpcHttpOutcome LmzTestClient::rpcHttp(const RpcHttpRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RpcHttpOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RpcHttpOutcome(RpcHttpResult(outcome.result()));
+	else
+		return RpcHttpOutcome(outcome.error());
+}
+
+void LmzTestClient::rpcHttpAsync(const RpcHttpRequest& request, const RpcHttpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, rpcHttp(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::RpcHttpOutcomeCallable LmzTestClient::rpcHttpCallable(const RpcHttpRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RpcHttpOutcome()>>(
+			[this, request]()
+			{
+			return this->rpcHttp(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::TestPutApiAndGetApiOutcome LmzTestClient::testPutApiAndGetApi(const TestPutApiAndGetApiRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TestPutApiAndGetApiOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TestPutApiAndGetApiOutcome(TestPutApiAndGetApiResult(outcome.result()));
+	else
+		return TestPutApiAndGetApiOutcome(outcome.error());
+}
+
+void LmzTestClient::testPutApiAndGetApiAsync(const TestPutApiAndGetApiRequest& request, const TestPutApiAndGetApiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, testPutApiAndGetApi(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::TestPutApiAndGetApiOutcomeCallable LmzTestClient::testPutApiAndGetApiCallable(const TestPutApiAndGetApiRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TestPutApiAndGetApiOutcome()>>(
+			[this, request]()
+			{
+			return this->testPutApiAndGetApi(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+LmzTestClient::UpdateListenerOutcome LmzTestClient::updateListener(const UpdateListenerRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateListenerOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateListenerOutcome(UpdateListenerResult(outcome.result()));
+	else
+		return UpdateListenerOutcome(outcome.error());
+}
+
+void LmzTestClient::updateListenerAsync(const UpdateListenerRequest& request, const UpdateListenerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateListener(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+LmzTestClient::UpdateListenerOutcomeCallable LmzTestClient::updateListenerCallable(const UpdateListenerRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateListenerOutcome()>>(
+			[this, request]()
+			{
+			return this->updateListener(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

lmztest/src/model/AAbckRequest.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/lmztest/model/AAbckRequest.h>
+
+using AlibabaCloud::LmzTest::Model::AAbckRequest;
+
+AAbckRequest::AAbckRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "AAbck") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+AAbckRequest::~AAbckRequest() {}
+
+std::string AAbckRequest::getClientToken3() const {
+  return clientToken3_;
+}
+
+void AAbckRequest::setClientToken3(const std::string &clientToken3) {
+  clientToken3_ = clientToken3;
+  setParameter(std::string("ClientToken3"), clientToken3);
+}
+
+std::string AAbckRequest::getTestDemo() const {
+  return testDemo_;
+}
+
+void AAbckRequest::setTestDemo(const std::string &testDemo) {
+  testDemo_ = testDemo;
+  setParameter(std::string("TestDemo"), testDemo);
+}
+

lmztest/src/model/AAbckResult.cc

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

lmztest/src/model/AndBackRequest.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/lmztest/model/AndBackRequest.h>
+
+using AlibabaCloud::LmzTest::Model::AndBackRequest;
+
+AndBackRequest::AndBackRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "AndBack") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+AndBackRequest::~AndBackRequest() {}
+
+std::string AndBackRequest::getClientToken2() const {
+  return clientToken2_;
+}
+
+void AndBackRequest::setClientToken2(const std::string &clientToken2) {
+  clientToken2_ = clientToken2;
+  setParameter(std::string("ClientToken2"), clientToken2);
+}
+
+std::string AndBackRequest::getTestDemo() const {
+  return testDemo_;
+}
+
+void AndBackRequest::setTestDemo(const std::string &testDemo) {
+  testDemo_ = testDemo;
+  setParameter(std::string("TestDemo"), testDemo);
+}
+

lmztest/src/model/AndBackResult.cc

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

lmztest/src/model/DataRateLimitTestRequest.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/lmztest/model/DataRateLimitTestRequest.h>
+
+using AlibabaCloud::LmzTest::Model::DataRateLimitTestRequest;
+
+DataRateLimitTestRequest::DataRateLimitTestRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "DataRateLimitTest") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+DataRateLimitTestRequest::~DataRateLimitTestRequest() {}
+

lmztest/src/model/DataRateLimitTestResult.cc

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

lmztest/src/model/DemoGrayReleaseTestRequest.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/lmztest/model/DemoGrayReleaseTestRequest.h>
+
+using AlibabaCloud::LmzTest::Model::DemoGrayReleaseTestRequest;
+
+DemoGrayReleaseTestRequest::DemoGrayReleaseTestRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "DemoGrayReleaseTest") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DemoGrayReleaseTestRequest::~DemoGrayReleaseTestRequest() {}
+
+int DemoGrayReleaseTestRequest::getNumberCode() const {
+  return numberCode_;
+}
+
+void DemoGrayReleaseTestRequest::setNumberCode(int numberCode) {
+  numberCode_ = numberCode;
+  setParameter(std::string("NumberCode"), std::to_string(numberCode));
+}
+
+std::string DemoGrayReleaseTestRequest::getId() const {
+  return id_;
+}
+
+void DemoGrayReleaseTestRequest::setId(const std::string &id) {
+  id_ = id;
+  setParameter(std::string("Id"), id);
+}
+

lmztest/src/model/DemoGrayReleaseTestResult.cc

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

lmztest/src/model/DemoGrayReleaseTestTwoRequest.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/lmztest/model/DemoGrayReleaseTestTwoRequest.h>
+
+using AlibabaCloud::LmzTest::Model::DemoGrayReleaseTestTwoRequest;
+
+DemoGrayReleaseTestTwoRequest::DemoGrayReleaseTestTwoRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "DemoGrayReleaseTestTwo") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DemoGrayReleaseTestTwoRequest::~DemoGrayReleaseTestTwoRequest() {}
+
+std::string DemoGrayReleaseTestTwoRequest::getNumberCode() const {
+  return numberCode_;
+}
+
+void DemoGrayReleaseTestTwoRequest::setNumberCode(const std::string &numberCode) {
+  numberCode_ = numberCode;
+  setParameter(std::string("NumberCode"), numberCode);
+}
+
+long DemoGrayReleaseTestTwoRequest::getCode() const {
+  return code_;
+}
+
+void DemoGrayReleaseTestTwoRequest::setCode(long code) {
+  code_ = code;
+  setParameter(std::string("Code"), std::to_string(code));
+}
+

lmztest/src/model/DemoGrayReleaseTestTwoResult.cc

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

lmztest/src/model/DemoGreyReleaseTestRequest.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/lmztest/model/DemoGreyReleaseTestRequest.h>
+
+using AlibabaCloud::LmzTest::Model::DemoGreyReleaseTestRequest;
+
+DemoGreyReleaseTestRequest::DemoGreyReleaseTestRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "DemoGreyReleaseTest") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DemoGreyReleaseTestRequest::~DemoGreyReleaseTestRequest() {}
+
+long DemoGreyReleaseTestRequest::getNumber() const {
+  return number_;
+}
+
+void DemoGreyReleaseTestRequest::setNumber(long number) {
+  number_ = number;
+  setParameter(std::string("Number"), std::to_string(number));
+}
+

lmztest/src/model/DemoGreyReleaseTestResult.cc

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

lmztest/src/model/DemoHsfNineResponseRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/lmztest/model/DemoHsfNineResponseRequest.h>
+
+using AlibabaCloud::LmzTest::Model::DemoHsfNineResponseRequest;
+
+DemoHsfNineResponseRequest::DemoHsfNineResponseRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "DemoHsfNineResponse") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DemoHsfNineResponseRequest::~DemoHsfNineResponseRequest() {}
+
+std::string DemoHsfNineResponseRequest::getName() const {
+  return name_;
+}
+
+void DemoHsfNineResponseRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("name"), name);
+}
+
+std::string DemoHsfNineResponseRequest::getTestF1() const {
+  return testF1_;
+}
+
+void DemoHsfNineResponseRequest::setTestF1(const std::string &testF1) {
+  testF1_ = testF1;
+  setParameter(std::string("TestF1"), testF1);
+}
+
+std::map<std::string, DemoHsfNineResponseRequest::userMap> DemoHsfNineResponseRequest::getUserMap() const {
+  return userMap_;
+}
+
+void DemoHsfNineResponseRequest::setUserMap(const std::map<std::string, DemoHsfNineResponseRequest::userMap> &userMap) {
+  userMap_ = userMap;
+  for(auto const &iter1 : userMap) {
+    setParameter(std::string("userMap") + "." + iter1.first + ".Uaa", iter1.second.uaa);
+    setParameter(std::string("userMap") + "." + iter1.first + ".Uas", iter1.second.uas);
+    setParameter(std::string("userMap") + "." + iter1.first + ".name", iter1.second.name);
+    setParameter(std::string("userMap") + "." + iter1.first + ".id", iter1.second.id);
+  }
+}
+

lmztest/src/model/DemoHsfNineResponseResult.cc

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

lmztest/src/model/DemoHsfSixTestRequest.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/lmztest/model/DemoHsfSixTestRequest.h>
+
+using AlibabaCloud::LmzTest::Model::DemoHsfSixTestRequest;
+
+DemoHsfSixTestRequest::DemoHsfSixTestRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "DemoHsfSixTest") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DemoHsfSixTestRequest::~DemoHsfSixTestRequest() {}
+
+std::vector<DemoHsfSixTestRequest::std::map<std::string, std::map<std::string, ObjectOfAny>>> DemoHsfSixTestRequest::getStrListMap() const {
+  return strListMap_;
+}
+
+void DemoHsfSixTestRequest::setStrListMap(const std::vector<DemoHsfSixTestRequest::std::map<std::string, std::map<std::string, ObjectOfAny>>> &strListMap) {
+  strListMap_ = strListMap;
+  for(int dep1 = 0; dep1 != strListMap.size(); dep1++) {
+    for(auto const &iter2 : strListMap[dep1]) {
+      for(auto const &iter3 : iter2.second) {
+        setBodyParameter(std::string("StrListMap") + "." + std::to_string(dep1 + 1) + "." + iter2.first + "." + iter3.first, std::to_string(iter3.second));
+      }
+    }
+  }
+}
+
+std::string DemoHsfSixTestRequest::getData() const {
+  return data_;
+}
+
+void DemoHsfSixTestRequest::setData(const std::string &data) {
+  data_ = data;
+  setBodyParameter(std::string("Data"), data);
+}
+
+std::string DemoHsfSixTestRequest::getMap() const {
+  return map_;
+}
+
+void DemoHsfSixTestRequest::setMap(const std::string &map) {
+  map_ = map;
+  setBodyParameter(std::string("Map"), map);
+}
+
+std::map<std::string, DemoHsfSixTestRequest::codeMap> DemoHsfSixTestRequest::getCodeMap() const {
+  return codeMap_;
+}
+
+void DemoHsfSixTestRequest::setCodeMap(const std::map<std::string, DemoHsfSixTestRequest::codeMap> &codeMap) {
+  codeMap_ = codeMap;
+  for(auto const &iter1 : codeMap) {
+    setParameter(std::string("codeMap") + "." + iter1.first + ".Name", iter1.second.name);
+    setParameter(std::string("codeMap") + "." + iter1.first + ".Id", iter1.second.id);
+  }
+}
+

lmztest/src/model/DemoHsfSixTestResult.cc

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

lmztest/src/model/DemoHttpComplexResponseRequest.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/lmztest/model/DemoHttpComplexResponseRequest.h>
+
+using AlibabaCloud::LmzTest::Model::DemoHttpComplexResponseRequest;
+
+DemoHttpComplexResponseRequest::DemoHttpComplexResponseRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "DemoHttpComplexResponse") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DemoHttpComplexResponseRequest::~DemoHttpComplexResponseRequest() {}
+
+std::string DemoHttpComplexResponseRequest::getReqInfo() const {
+  return reqInfo_;
+}
+
+void DemoHttpComplexResponseRequest::setReqInfo(const std::string &reqInfo) {
+  reqInfo_ = reqInfo;
+  setParameter(std::string("reqInfo"), reqInfo);
+}
+

lmztest/src/model/DemoHttpComplexResponseResult.cc

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

lmztest/src/model/DescribeDisksRequest.cc

@@ -0,0 +1,364 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/lmztest/model/DescribeDisksRequest.h>
+
+using AlibabaCloud::LmzTest::Model::DescribeDisksRequest;
+
+DescribeDisksRequest::DescribeDisksRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "DescribeDisks") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDisksRequest::~DescribeDisksRequest() {}
+
+long DescribeDisksRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeDisksRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDisksRequest::getFilter2Value() const {
+  return filter2Value_;
+}
+
+void DescribeDisksRequest::setFilter2Value(const std::string &filter2Value) {
+  filter2Value_ = filter2Value;
+  setParameter(std::string("Filter.2.Value"), filter2Value);
+}
+
+std::string DescribeDisksRequest::getAutoSnapshotPolicyId() const {
+  return autoSnapshotPolicyId_;
+}
+
+void DescribeDisksRequest::setAutoSnapshotPolicyId(const std::string &autoSnapshotPolicyId) {
+  autoSnapshotPolicyId_ = autoSnapshotPolicyId;
+  setParameter(std::string("AutoSnapshotPolicyId"), autoSnapshotPolicyId);
+}
+
+std::string DescribeDisksRequest::getDiskName() const {
+  return diskName_;
+}
+
+void DescribeDisksRequest::setDiskName(const std::string &diskName) {
+  diskName_ = diskName;
+  setParameter(std::string("DiskName"), diskName);
+}
+
+bool DescribeDisksRequest::getDeleteAutoSnapshot() const {
+  return deleteAutoSnapshot_;
+}
+
+void DescribeDisksRequest::setDeleteAutoSnapshot(bool deleteAutoSnapshot) {
+  deleteAutoSnapshot_ = deleteAutoSnapshot;
+  setParameter(std::string("DeleteAutoSnapshot"), deleteAutoSnapshot ? "true" : "false");
+}
+
+std::string DescribeDisksRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void DescribeDisksRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string DescribeDisksRequest::getDiskChargeType() const {
+  return diskChargeType_;
+}
+
+void DescribeDisksRequest::setDiskChargeType(const std::string &diskChargeType) {
+  diskChargeType_ = diskChargeType;
+  setParameter(std::string("DiskChargeType"), diskChargeType);
+}
+
+std::string DescribeDisksRequest::getLockReason() const {
+  return lockReason_;
+}
+
+void DescribeDisksRequest::setLockReason(const std::string &lockReason) {
+  lockReason_ = lockReason;
+  setParameter(std::string("LockReason"), lockReason);
+}
+
+std::string DescribeDisksRequest::getFilter1Key() const {
+  return filter1Key_;
+}
+
+void DescribeDisksRequest::setFilter1Key(const std::string &filter1Key) {
+  filter1Key_ = filter1Key;
+  setParameter(std::string("Filter.1.Key"), filter1Key);
+}
+
+std::vector<DescribeDisksRequest::Tag> DescribeDisksRequest::getTag() const {
+  return tag_;
+}
+
+void DescribeDisksRequest::setTag(const std::vector<DescribeDisksRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
+}
+
+bool DescribeDisksRequest::getEnableAutoSnapshot() const {
+  return enableAutoSnapshot_;
+}
+
+void DescribeDisksRequest::setEnableAutoSnapshot(bool enableAutoSnapshot) {
+  enableAutoSnapshot_ = enableAutoSnapshot;
+  setParameter(std::string("EnableAutoSnapshot"), enableAutoSnapshot ? "true" : "false");
+}
+
+bool DescribeDisksRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void DescribeDisksRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string DescribeDisksRequest::getFilter1Value() const {
+  return filter1Value_;
+}
+
+void DescribeDisksRequest::setFilter1Value(const std::string &filter1Value) {
+  filter1Value_ = filter1Value;
+  setParameter(std::string("Filter.1.Value"), filter1Value);
+}
+
+bool DescribeDisksRequest::getPortable() const {
+  return portable_;
+}
+
+void DescribeDisksRequest::setPortable(bool portable) {
+  portable_ = portable;
+  setParameter(std::string("Portable"), portable ? "true" : "false");
+}
+
+long DescribeDisksRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeDisksRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::vector<std::string> DescribeDisksRequest::getAdditionalAttributes() const {
+  return additionalAttributes_;
+}
+
+void DescribeDisksRequest::setAdditionalAttributes(const std::vector<std::string> &additionalAttributes) {
+  additionalAttributes_ = additionalAttributes;
+}
+
+std::string DescribeDisksRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DescribeDisksRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string DescribeDisksRequest::getZoneId() const {
+  return zoneId_;
+}
+
+void DescribeDisksRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
+}
+
+int DescribeDisksRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeDisksRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string DescribeDisksRequest::getStatus() const {
+  return status_;
+}
+
+void DescribeDisksRequest::setStatus(const std::string &status) {
+  status_ = status;
+  setParameter(std::string("Status"), status);
+}
+
+std::string DescribeDisksRequest::getSnapshotId() const {
+  return snapshotId_;
+}
+
+void DescribeDisksRequest::setSnapshotId(const std::string &snapshotId) {
+  snapshotId_ = snapshotId;
+  setParameter(std::string("SnapshotId"), snapshotId);
+}
+
+int DescribeDisksRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeDisksRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeDisksRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDisksRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDisksRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void DescribeDisksRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+int DescribeDisksRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeDisksRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeDisksRequest::getDiskIds() const {
+  return diskIds_;
+}
+
+void DescribeDisksRequest::setDiskIds(const std::string &diskIds) {
+  diskIds_ = diskIds;
+  setParameter(std::string("DiskIds"), diskIds);
+}
+
+std::string DescribeDisksRequest::getMultiAttach() const {
+  return multiAttach_;
+}
+
+void DescribeDisksRequest::setMultiAttach(const std::string &multiAttach) {
+  multiAttach_ = multiAttach;
+  setParameter(std::string("MultiAttach"), multiAttach);
+}
+
+bool DescribeDisksRequest::getDeleteWithInstance() const {
+  return deleteWithInstance_;
+}
+
+void DescribeDisksRequest::setDeleteWithInstance(bool deleteWithInstance) {
+  deleteWithInstance_ = deleteWithInstance;
+  setParameter(std::string("DeleteWithInstance"), deleteWithInstance ? "true" : "false");
+}
+
+std::string DescribeDisksRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeDisksRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeDisksRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeDisksRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+bool DescribeDisksRequest::getEnableAutomatedSnapshotPolicy() const {
+  return enableAutomatedSnapshotPolicy_;
+}
+
+void DescribeDisksRequest::setEnableAutomatedSnapshotPolicy(bool enableAutomatedSnapshotPolicy) {
+  enableAutomatedSnapshotPolicy_ = enableAutomatedSnapshotPolicy;
+  setParameter(std::string("EnableAutomatedSnapshotPolicy"), enableAutomatedSnapshotPolicy ? "true" : "false");
+}
+
+std::string DescribeDisksRequest::getFilter2Key() const {
+  return filter2Key_;
+}
+
+void DescribeDisksRequest::setFilter2Key(const std::string &filter2Key) {
+  filter2Key_ = filter2Key;
+  setParameter(std::string("Filter.2.Key"), filter2Key);
+}
+
+std::string DescribeDisksRequest::getDiskType() const {
+  return diskType_;
+}
+
+void DescribeDisksRequest::setDiskType(const std::string &diskType) {
+  diskType_ = diskType;
+  setParameter(std::string("DiskType"), diskType);
+}
+
+bool DescribeDisksRequest::getEnableShared() const {
+  return enableShared_;
+}
+
+void DescribeDisksRequest::setEnableShared(bool enableShared) {
+  enableShared_ = enableShared;
+  setParameter(std::string("EnableShared"), enableShared ? "true" : "false");
+}
+
+bool DescribeDisksRequest::getEncrypted() const {
+  return encrypted_;
+}
+
+void DescribeDisksRequest::setEncrypted(bool encrypted) {
+  encrypted_ = encrypted;
+  setParameter(std::string("Encrypted"), encrypted ? "true" : "false");
+}
+
+std::string DescribeDisksRequest::getCategory() const {
+  return category_;
+}
+
+void DescribeDisksRequest::setCategory(const std::string &category) {
+  category_ = category;
+  setParameter(std::string("Category"), category);
+}
+
+std::string DescribeDisksRequest::getKMSKeyId() const {
+  return kMSKeyId_;
+}
+
+void DescribeDisksRequest::setKMSKeyId(const std::string &kMSKeyId) {
+  kMSKeyId_ = kMSKeyId;
+  setParameter(std::string("KMSKeyId"), kMSKeyId);
+}
+

lmztest/src/model/DescribeDisksResult.cc

@@ -0,0 +1,203 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/lmztest/model/DescribeDisksResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::LmzTest;
+using namespace AlibabaCloud::LmzTest::Model;
+
+DescribeDisksResult::DescribeDisksResult() :
+	ServiceResult()
+{}
+
+DescribeDisksResult::DescribeDisksResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDisksResult::~DescribeDisksResult()
+{}
+
+void DescribeDisksResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDisksNode = value["Disks"]["Disk"];
+	for (auto valueDisksDisk : allDisksNode)
+	{
+		Disk disksObject;
+		if(!valueDisksDisk["Type"].isNull())
+			disksObject.type = valueDisksDisk["Type"].asString();
+		if(!valueDisksDisk["Status"].isNull())
+			disksObject.status = valueDisksDisk["Status"].asString();
+		if(!valueDisksDisk["CreationTime"].isNull())
+			disksObject.creationTime = valueDisksDisk["CreationTime"].asString();
+		if(!valueDisksDisk["SerialNumber"].isNull())
+			disksObject.serialNumber = valueDisksDisk["SerialNumber"].asString();
+		if(!valueDisksDisk["PerformanceLevel"].isNull())
+			disksObject.performanceLevel = valueDisksDisk["PerformanceLevel"].asString();
+		if(!valueDisksDisk["EnableAutoSnapshot"].isNull())
+			disksObject.enableAutoSnapshot = valueDisksDisk["EnableAutoSnapshot"].asString() == "true";
+		if(!valueDisksDisk["BdfId"].isNull())
+			disksObject.bdfId = valueDisksDisk["BdfId"].asString();
+		if(!valueDisksDisk["StorageSetId"].isNull())
+			disksObject.storageSetId = valueDisksDisk["StorageSetId"].asString();
+		if(!valueDisksDisk["DiskId"].isNull())
+			disksObject.diskId = valueDisksDisk["DiskId"].asString();
+		if(!valueDisksDisk["StorageSetPartitionNumber"].isNull())
+			disksObject.storageSetPartitionNumber = std::stoi(valueDisksDisk["StorageSetPartitionNumber"].asString());
+		if(!valueDisksDisk["MultiAttach"].isNull())
+			disksObject.multiAttach = valueDisksDisk["MultiAttach"].asString();
+		if(!valueDisksDisk["DeleteAutoSnapshot"].isNull())
+			disksObject.deleteAutoSnapshot = valueDisksDisk["DeleteAutoSnapshot"].asString() == "true";
+		if(!valueDisksDisk["Encrypted"].isNull())
+			disksObject.encrypted = valueDisksDisk["Encrypted"].asString() == "true";
+		if(!valueDisksDisk["DedicatedBlockStorageClusterId"].isNull())
+			disksObject.dedicatedBlockStorageClusterId = valueDisksDisk["DedicatedBlockStorageClusterId"].asString();
+		if(!valueDisksDisk["IOPSRead"].isNull())
+			disksObject.iOPSRead = std::stoi(valueDisksDisk["IOPSRead"].asString());
+		if(!valueDisksDisk["MountInstanceNum"].isNull())
+			disksObject.mountInstanceNum = std::stoi(valueDisksDisk["MountInstanceNum"].asString());
+		if(!valueDisksDisk["Description"].isNull())
+			disksObject.description = valueDisksDisk["Description"].asString();
+		if(!valueDisksDisk["Device"].isNull())
+			disksObject.device = valueDisksDisk["Device"].asString();
+		if(!valueDisksDisk["DiskName"].isNull())
+			disksObject.diskName = valueDisksDisk["DiskName"].asString();
+		if(!valueDisksDisk["Portable"].isNull())
+			disksObject.portable = valueDisksDisk["Portable"].asString() == "true";
+		if(!valueDisksDisk["ImageId"].isNull())
+			disksObject.imageId = valueDisksDisk["ImageId"].asString();
+		if(!valueDisksDisk["DeleteWithInstance"].isNull())
+			disksObject.deleteWithInstance = valueDisksDisk["DeleteWithInstance"].asString() == "true";
+		if(!valueDisksDisk["KMSKeyId"].isNull())
+			disksObject.kMSKeyId = valueDisksDisk["KMSKeyId"].asString();
+		if(!valueDisksDisk["DetachedTime"].isNull())
+			disksObject.detachedTime = valueDisksDisk["DetachedTime"].asString();
+		if(!valueDisksDisk["SourceSnapshotId"].isNull())
+			disksObject.sourceSnapshotId = valueDisksDisk["SourceSnapshotId"].asString();
+		if(!valueDisksDisk["AutoSnapshotPolicyId"].isNull())
+			disksObject.autoSnapshotPolicyId = valueDisksDisk["AutoSnapshotPolicyId"].asString();
+		if(!valueDisksDisk["EnableAutomatedSnapshotPolicy"].isNull())
+			disksObject.enableAutomatedSnapshotPolicy = valueDisksDisk["EnableAutomatedSnapshotPolicy"].asString() == "true";
+		if(!valueDisksDisk["IOPSWrite"].isNull())
+			disksObject.iOPSWrite = std::stoi(valueDisksDisk["IOPSWrite"].asString());
+		if(!valueDisksDisk["InstanceId"].isNull())
+			disksObject.instanceId = valueDisksDisk["InstanceId"].asString();
+		if(!valueDisksDisk["RegionId"].isNull())
+			disksObject.regionId = valueDisksDisk["RegionId"].asString();
+		if(!valueDisksDisk["IOPS"].isNull())
+			disksObject.iOPS = std::stoi(valueDisksDisk["IOPS"].asString());
+		if(!valueDisksDisk["ExpiredTime"].isNull())
+			disksObject.expiredTime = valueDisksDisk["ExpiredTime"].asString();
+		if(!valueDisksDisk["Size"].isNull())
+			disksObject.size = std::stoi(valueDisksDisk["Size"].asString());
+		if(!valueDisksDisk["ResourceGroupId"].isNull())
+			disksObject.resourceGroupId = valueDisksDisk["ResourceGroupId"].asString();
+		if(!valueDisksDisk["ZoneId"].isNull())
+			disksObject.zoneId = valueDisksDisk["ZoneId"].asString();
+		if(!valueDisksDisk["DiskChargeType"].isNull())
+			disksObject.diskChargeType = valueDisksDisk["DiskChargeType"].asString();
+		if(!valueDisksDisk["Category"].isNull())
+			disksObject.category = valueDisksDisk["Category"].asString();
+		if(!valueDisksDisk["AttachedTime"].isNull())
+			disksObject.attachedTime = valueDisksDisk["AttachedTime"].asString();
+		if(!valueDisksDisk["ProductCode"].isNull())
+			disksObject.productCode = valueDisksDisk["ProductCode"].asString();
+		auto allOperationLocksNode = valueDisksDisk["OperationLocks"]["OperationLock"];
+		for (auto valueDisksDiskOperationLocksOperationLock : allOperationLocksNode)
+		{
+			Disk::OperationLock operationLocksObject;
+			if(!valueDisksDiskOperationLocksOperationLock["LockReason"].isNull())
+				operationLocksObject.lockReason = valueDisksDiskOperationLocksOperationLock["LockReason"].asString();
+			disksObject.operationLocks.push_back(operationLocksObject);
+		}
+		auto allMountInstancesNode = valueDisksDisk["MountInstances"]["MountInstance"];
+		for (auto valueDisksDiskMountInstancesMountInstance : allMountInstancesNode)
+		{
+			Disk::MountInstance mountInstancesObject;
+			if(!valueDisksDiskMountInstancesMountInstance["AttachedTime"].isNull())
+				mountInstancesObject.attachedTime = valueDisksDiskMountInstancesMountInstance["AttachedTime"].asString();
+			if(!valueDisksDiskMountInstancesMountInstance["InstanceId"].isNull())
+				mountInstancesObject.instanceId = valueDisksDiskMountInstancesMountInstance["InstanceId"].asString();
+			if(!valueDisksDiskMountInstancesMountInstance["Device"].isNull())
+				mountInstancesObject.device = valueDisksDiskMountInstancesMountInstance["Device"].asString();
+			disksObject.mountInstances.push_back(mountInstancesObject);
+		}
+		auto allTagsNode = valueDisksDisk["Tags"]["Tag"];
+		for (auto valueDisksDiskTagsTag : allTagsNode)
+		{
+			Disk::Tag tagsObject;
+			if(!valueDisksDiskTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueDisksDiskTagsTag["TagKey"].asString();
+			if(!valueDisksDiskTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueDisksDiskTagsTag["TagValue"].asString();
+			disksObject.tags.push_back(tagsObject);
+		}
+		auto allAttachmentsNode = valueDisksDisk["Attachments"]["Attachment"];
+		for (auto valueDisksDiskAttachmentsAttachment : allAttachmentsNode)
+		{
+			Disk::Attachment attachmentsObject;
+			if(!valueDisksDiskAttachmentsAttachment["AttachedTime"].isNull())
+				attachmentsObject.attachedTime = valueDisksDiskAttachmentsAttachment["AttachedTime"].asString();
+			if(!valueDisksDiskAttachmentsAttachment["InstanceId"].isNull())
+				attachmentsObject.instanceId = valueDisksDiskAttachmentsAttachment["InstanceId"].asString();
+			if(!valueDisksDiskAttachmentsAttachment["Device"].isNull())
+				attachmentsObject.device = valueDisksDiskAttachmentsAttachment["Device"].asString();
+			disksObject.attachments.push_back(attachmentsObject);
+		}
+		disks_.push_back(disksObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeDisksResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string DescribeDisksResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+int DescribeDisksResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeDisksResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeDisksResult::Disk> DescribeDisksResult::getDisks()const
+{
+	return disks_;
+}
+

lmztest/src/model/GetPackageStorageCredentialRequest.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/lmztest/model/GetPackageStorageCredentialRequest.h>
+
+using AlibabaCloud::LmzTest::Model::GetPackageStorageCredentialRequest;
+
+GetPackageStorageCredentialRequest::GetPackageStorageCredentialRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "GetPackageStorageCredential") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetPackageStorageCredentialRequest::~GetPackageStorageCredentialRequest() {}
+

lmztest/src/model/GetPackageStorageCredentialResult.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/lmztest/model/GetPackageStorageCredentialResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::LmzTest;
+using namespace AlibabaCloud::LmzTest::Model;
+
+GetPackageStorageCredentialResult::GetPackageStorageCredentialResult() :
+	ServiceResult()
+{}
+
+GetPackageStorageCredentialResult::GetPackageStorageCredentialResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetPackageStorageCredentialResult::~GetPackageStorageCredentialResult()
+{}
+
+void GetPackageStorageCredentialResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto credentialNode = value["Credential"];
+	if(!credentialNode["KeyPrefix"].isNull())
+		credential_.keyPrefix = credentialNode["KeyPrefix"].asString();
+	if(!credentialNode["SecurityToken"].isNull())
+		credential_.securityToken = credentialNode["SecurityToken"].asString();
+	if(!credentialNode["AccessKeySecret"].isNull())
+		credential_.accessKeySecret = credentialNode["AccessKeySecret"].asString();
+	if(!credentialNode["Expiration"].isNull())
+		credential_.expiration = credentialNode["Expiration"].asString();
+	if(!credentialNode["AccessKeyId"].isNull())
+		credential_.accessKeyId = credentialNode["AccessKeyId"].asString();
+	if(!credentialNode["Bucket"].isNull())
+		credential_.bucket = credentialNode["Bucket"].asString();
+	if(!credentialNode["RegionId"].isNull())
+		credential_.regionId = credentialNode["RegionId"].asString();
+	if(!credentialNode["OssPublicEndpoint"].isNull())
+		credential_.ossPublicEndpoint = credentialNode["OssPublicEndpoint"].asString();
+	if(!credentialNode["OssInternalEndpoint"].isNull())
+		credential_.ossInternalEndpoint = credentialNode["OssInternalEndpoint"].asString();
+	if(!credentialNode["OssVpcEndpoint"].isNull())
+		credential_.ossVpcEndpoint = credentialNode["OssVpcEndpoint"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+GetPackageStorageCredentialResult::Credential GetPackageStorageCredentialResult::getCredential()const
+{
+	return credential_;
+}
+
+std::string GetPackageStorageCredentialResult::getMessage()const
+{
+	return message_;
+}
+
+int GetPackageStorageCredentialResult::getCode()const
+{
+	return code_;
+}
+

lmztest/src/model/GrayReleaseDemoRequest.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/lmztest/model/GrayReleaseDemoRequest.h>
+
+using AlibabaCloud::LmzTest::Model::GrayReleaseDemoRequest;
+
+GrayReleaseDemoRequest::GrayReleaseDemoRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "GrayReleaseDemo") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GrayReleaseDemoRequest::~GrayReleaseDemoRequest() {}
+
+std::string GrayReleaseDemoRequest::getId() const {
+  return id_;
+}
+
+void GrayReleaseDemoRequest::setId(const std::string &id) {
+  id_ = id;
+  setParameter(std::string("Id"), id);
+}
+

lmztest/src/model/GrayReleaseDemoResult.cc

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

lmztest/src/model/ListProductsByPopCodeRequest.cc

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/lmztest/model/ListProductsByPopCodeRequest.h>
+
+using AlibabaCloud::LmzTest::Model::ListProductsByPopCodeRequest;
+
+ListProductsByPopCodeRequest::ListProductsByPopCodeRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "ListProductsByPopCode") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ListProductsByPopCodeRequest::~ListProductsByPopCodeRequest() {}
+
+std::string ListProductsByPopCodeRequest::getAuthKey() const {
+  return authKey_;
+}
+
+void ListProductsByPopCodeRequest::setAuthKey(const std::string &authKey) {
+  authKey_ = authKey;
+  setParameter(std::string("AuthKey"), authKey);
+}
+
+std::string ListProductsByPopCodeRequest::getExtraParams() const {
+  return extraParams_;
+}
+
+void ListProductsByPopCodeRequest::setExtraParams(const std::string &extraParams) {
+  extraParams_ = extraParams;
+  setBodyParameter(std::string("ExtraParams"), extraParams);
+}
+
+std::string ListProductsByPopCodeRequest::getServerClientIp() const {
+  return serverClientIp_;
+}
+
+void ListProductsByPopCodeRequest::setServerClientIp(const std::string &serverClientIp) {
+  serverClientIp_ = serverClientIp;
+  setParameter(std::string("ServerClientIp"), serverClientIp);
+}
+
+std::string ListProductsByPopCodeRequest::getRequestId() const {
+  return requestId_;
+}
+
+void ListProductsByPopCodeRequest::setRequestId(const std::string &requestId) {
+  requestId_ = requestId;
+  setParameter(std::string("RequestId"), requestId);
+}
+
+std::string ListProductsByPopCodeRequest::getClientIp() const {
+  return clientIp_;
+}
+
+void ListProductsByPopCodeRequest::setClientIp(const std::string &clientIp) {
+  clientIp_ = clientIp;
+  setParameter(std::string("ClientIp"), clientIp);
+}
+
+std::string ListProductsByPopCodeRequest::getIdentityDTO() const {
+  return identityDTO_;
+}
+
+void ListProductsByPopCodeRequest::setIdentityDTO(const std::string &identityDTO) {
+  identityDTO_ = identityDTO;
+  setBodyParameter(std::string("IdentityDTO"), identityDTO);
+}
+
+std::string ListProductsByPopCodeRequest::getEnv() const {
+  return env_;
+}
+
+void ListProductsByPopCodeRequest::setEnv(const std::string &env) {
+  env_ = env;
+  setParameter(std::string("Env"), env);
+}
+
+std::string ListProductsByPopCodeRequest::getPopCode() const {
+  return popCode_;
+}
+
+void ListProductsByPopCodeRequest::setPopCode(const std::string &popCode) {
+  popCode_ = popCode;
+  setParameter(std::string("PopCode"), popCode);
+}
+

lmztest/src/model/ListProductsByPopCodeResult.cc

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/lmztest/model/ListProductsByPopCodeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::LmzTest;
+using namespace AlibabaCloud::LmzTest::Model;
+
+ListProductsByPopCodeResult::ListProductsByPopCodeResult() :
+	ServiceResult()
+{}
+
+ListProductsByPopCodeResult::ListProductsByPopCodeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListProductsByPopCodeResult::~ListProductsByPopCodeResult()
+{}
+
+void ListProductsByPopCodeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allResultNode = value["Result"]["ResultItem"];
+	for (auto valueResultResultItem : allResultNode)
+	{
+		ResultItem resultObject;
+		auto uniqueKeyDTONode = value["UniqueKeyDTO"];
+		if(!uniqueKeyDTONode["NamespaceCode"].isNull())
+			resultObject.uniqueKeyDTO.namespaceCode = uniqueKeyDTONode["NamespaceCode"].asString();
+		auto nameSpaceExtDTONode = value["NameSpaceExtDTO"];
+		auto allBusinessOwnerListNode = nameSpaceExtDTONode["BusinessOwnerList"]["BusinessOwnerListItem"];
+		for (auto nameSpaceExtDTONodeBusinessOwnerListBusinessOwnerListItem : allBusinessOwnerListNode)
+		{
+			ResultItem::NameSpaceExtDTO::BusinessOwnerListItem businessOwnerListItemObject;
+			if(!nameSpaceExtDTONodeBusinessOwnerListBusinessOwnerListItem["BucId"].isNull())
+				businessOwnerListItemObject.bucId = nameSpaceExtDTONodeBusinessOwnerListBusinessOwnerListItem["BucId"].asString();
+			if(!nameSpaceExtDTONodeBusinessOwnerListBusinessOwnerListItem["Name"].isNull())
+				businessOwnerListItemObject.name = nameSpaceExtDTONodeBusinessOwnerListBusinessOwnerListItem["Name"].asString();
+			if(!nameSpaceExtDTONodeBusinessOwnerListBusinessOwnerListItem["Id"].isNull())
+				businessOwnerListItemObject.id = nameSpaceExtDTONodeBusinessOwnerListBusinessOwnerListItem["Id"].asString();
+			resultObject.nameSpaceExtDTO.businessOwnerList.push_back(businessOwnerListItemObject);
+		}
+		auto allTechniqueOwnerListNode = nameSpaceExtDTONode["TechniqueOwnerList"]["TechniqueOwnerListItem"];
+		for (auto nameSpaceExtDTONodeTechniqueOwnerListTechniqueOwnerListItem : allTechniqueOwnerListNode)
+		{
+			ResultItem::NameSpaceExtDTO::TechniqueOwnerListItem techniqueOwnerListItemObject;
+			if(!nameSpaceExtDTONodeTechniqueOwnerListTechniqueOwnerListItem["BucId"].isNull())
+				techniqueOwnerListItemObject.bucId = nameSpaceExtDTONodeTechniqueOwnerListTechniqueOwnerListItem["BucId"].asString();
+			if(!nameSpaceExtDTONodeTechniqueOwnerListTechniqueOwnerListItem["Name"].isNull())
+				techniqueOwnerListItemObject.name = nameSpaceExtDTONodeTechniqueOwnerListTechniqueOwnerListItem["Name"].asString();
+			if(!nameSpaceExtDTONodeTechniqueOwnerListTechniqueOwnerListItem["Id"].isNull())
+				techniqueOwnerListItemObject.id = nameSpaceExtDTONodeTechniqueOwnerListTechniqueOwnerListItem["Id"].asString();
+			resultObject.nameSpaceExtDTO.techniqueOwnerList.push_back(techniqueOwnerListItemObject);
+		}
+		result_.push_back(resultObject);
+	}
+	if(!value["ErrorMessage"].isNull())
+		errorMessage_ = value["ErrorMessage"].asString();
+	if(!value["TraceId"].isNull())
+		traceId_ = value["TraceId"].asString();
+	if(!value["ErrorDetailMessage"].isNull())
+		errorDetailMessage_ = value["ErrorDetailMessage"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+
+}
+
+std::string ListProductsByPopCodeResult::getErrorDetailMessage()const
+{
+	return errorDetailMessage_;
+}
+
+std::string ListProductsByPopCodeResult::getTraceId()const
+{
+	return traceId_;
+}
+
+std::string ListProductsByPopCodeResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string ListProductsByPopCodeResult::getErrorMessage()const
+{
+	return errorMessage_;
+}
+
+bool ListProductsByPopCodeResult::getSuccess()const
+{
+	return success_;
+}
+
+std::vector<ListProductsByPopCodeResult::ResultItem> ListProductsByPopCodeResult::getResult()const
+{
+	return result_;
+}
+

lmztest/src/model/LjxTestRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/lmztest/model/LjxTestRequest.h>
+
+using AlibabaCloud::LmzTest::Model::LjxTestRequest;
+
+LjxTestRequest::LjxTestRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "LjxTest") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+LjxTestRequest::~LjxTestRequest() {}
+
+std::string LjxTestRequest::getNewparam2() const {
+  return newparam2_;
+}
+
+void LjxTestRequest::setNewparam2(const std::string &newparam2) {
+  newparam2_ = newparam2;
+  setParameter(std::string("new-param-2"), newparam2);
+}
+
+std::vector<LjxTestRequest::std::string> LjxTestRequest::getNewparam1() const {
+  return newparam1_;
+}
+
+void LjxTestRequest::setNewparam1(const std::vector<LjxTestRequest::std::string> &newparam1) {
+  newparam1_ = newparam1;
+  for(int dep1 = 0; dep1 != newparam1.size(); dep1++) {
+    setParameter(std::string("new-param-1") + "." + std::to_string(dep1 + 1), newparam1[dep1]);
+  }
+}
+
+std::map<std::string, std::string> LjxTestRequest::getCode() const {
+  return code_;
+}
+
+void LjxTestRequest::setCode(const std::map<std::string, std::string> &code) {
+  code_ = code;
+  for(auto const &iter1 : code) {
+    setParameter(std::string("code") + "." + iter1.first, iter1.second);
+  }
+}
+
+std::string LjxTestRequest::getId() const {
+  return id_;
+}
+
+void LjxTestRequest::setId(const std::string &id) {
+  id_ = id;
+  setParameter(std::string("id"), id);
+}
+
+std::string LjxTestRequest::getBody() const {
+  return body_;
+}
+
+void LjxTestRequest::setBody(const std::string &body) {
+  body_ = body;
+  setHeader(std::string("body"), body);
+}
+

lmztest/src/model/LjxTestResult.cc

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/lmztest/model/LjxTestResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::LmzTest;
+using namespace AlibabaCloud::LmzTest::Model;
+
+LjxTestResult::LjxTestResult() :
+	ServiceResult()
+{}
+
+LjxTestResult::LjxTestResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+LjxTestResult::~LjxTestResult()
+{}
+
+void LjxTestResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allMapsNode = value["Maps"]["mapsItem"];
+	for (auto valueMapsmapsItem : allMapsNode)
+	{
+		MapsItem mapsObject;
+		if(!valueMapsmapsItem["Param0"].isNull())
+			mapsObject.param0 = valueMapsmapsItem["Param0"].asString();
+		maps_.push_back(mapsObject);
+	}
+	auto testtestNode = value["testtest"];
+	if(!testtestNode["id"].isNull())
+		testtest_.id = testtestNode["id"].asString();
+	auto allStringList = value["StringList"]["stringList"];
+	for (const auto &item : allStringList)
+		stringList_.push_back(item.asString());
+	auto allLongList = value["LongList"]["longList"];
+	for (const auto &item : allLongList)
+		longList_.push_back(item.asString());
+	if(!value["Id"].isNull())
+		id_ = value["Id"].asString();
+	if(!value["Code"].isNull())
+		code_ = std::stoi(value["Code"].asString());
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
+
+}
+
+std::vector<LjxTestResult::MapsItem> LjxTestResult::getMaps()const
+{
+	return maps_;
+}
+
+std::vector<std::string> LjxTestResult::getStringList()const
+{
+	return stringList_;
+}
+
+LjxTestResult::Testtest LjxTestResult::getTesttest()const
+{
+	return testtest_;
+}
+
+std::vector<std::string> LjxTestResult::getLongList()const
+{
+	return longList_;
+}
+
+std::string LjxTestResult::getId()const
+{
+	return id_;
+}
+
+int LjxTestResult::getCode()const
+{
+	return code_;
+}
+
+std::string LjxTestResult::getName()const
+{
+	return name_;
+}
+

lmztest/src/model/ReqBeanTestRequest.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/lmztest/model/ReqBeanTestRequest.h>
+
+using AlibabaCloud::LmzTest::Model::ReqBeanTestRequest;
+
+ReqBeanTestRequest::ReqBeanTestRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "ReqBeanTest") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+ReqBeanTestRequest::~ReqBeanTestRequest() {}
+
+std::vector<ReqBeanTestRequest::std::string> ReqBeanTestRequest::getCodes() const {
+  return codes_;
+}
+
+void ReqBeanTestRequest::setCodes(const std::vector<ReqBeanTestRequest::std::string> &codes) {
+  codes_ = codes;
+  for(int dep1 = 0; dep1 != codes.size(); dep1++) {
+    setParameter(std::string("codes") + "." + std::to_string(dep1 + 1), codes[dep1]);
+  }
+}
+
+std::string ReqBeanTestRequest::getXhostheadertest() const {
+  return xhostheadertest_;
+}
+
+void ReqBeanTestRequest::setXhostheadertest(const std::string &xhostheadertest) {
+  xhostheadertest_ = xhostheadertest;
+  setHeader(std::string("x-host-header-test"), xhostheadertest);
+}
+
+std::string ReqBeanTestRequest::getId() const {
+  return id_;
+}
+
+void ReqBeanTestRequest::setId(const std::string &id) {
+  id_ = id;
+  setParameter(std::string("Id"), id);
+}
+
+std::vector<ReqBeanTestRequest::long> ReqBeanTestRequest::getNums() const {
+  return nums_;
+}
+
+void ReqBeanTestRequest::setNums(const std::vector<ReqBeanTestRequest::long> &nums) {
+  nums_ = nums;
+  for(int dep1 = 0; dep1 != nums.size(); dep1++) {
+    setParameter(std::string("nums") + "." + std::to_string(dep1 + 1), std::to_string(nums[dep1]));
+  }
+}
+
+std::vector<ReqBeanTestRequest::users> ReqBeanTestRequest::getUsers() const {
+  return users_;
+}
+
+void ReqBeanTestRequest::setUsers(const std::vector<ReqBeanTestRequest::users> &users) {
+  users_ = users;
+  for(int dep1 = 0; dep1 != users.size(); dep1++) {
+    setParameter(std::string("users") + "." + std::to_string(dep1 + 1) + ".name", users[dep1].name);
+    setParameter(std::string("users") + "." + std::to_string(dep1 + 1) + ".id", users[dep1].id);
+  }
+}
+

lmztest/src/model/ReqBeanTestResult.cc

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

lmztest/src/model/RomeGetExecutionResultRequest.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/lmztest/model/RomeGetExecutionResultRequest.h>
+
+using AlibabaCloud::LmzTest::Model::RomeGetExecutionResultRequest;
+
+RomeGetExecutionResultRequest::RomeGetExecutionResultRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "RomeGetExecutionResult") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+RomeGetExecutionResultRequest::~RomeGetExecutionResultRequest() {}
+
+std::string RomeGetExecutionResultRequest::getFlowRequestId() const {
+  return flowRequestId_;
+}
+
+void RomeGetExecutionResultRequest::setFlowRequestId(const std::string &flowRequestId) {
+  flowRequestId_ = flowRequestId;
+  setParameter(std::string("FlowRequestId"), flowRequestId);
+}
+

lmztest/src/model/RomeGetExecutionResultResult.cc

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

lmztest/src/model/RpcHttpRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/lmztest/model/RpcHttpRequest.h>
+
+using AlibabaCloud::LmzTest::Model::RpcHttpRequest;
+
+RpcHttpRequest::RpcHttpRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "RpcHttp") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+RpcHttpRequest::~RpcHttpRequest() {}
+
+std::string RpcHttpRequest::getNews() const {
+  return news_;
+}
+
+void RpcHttpRequest::setNews(const std::string &news) {
+  news_ = news;
+  setParameter(std::string("News"), news);
+}
+
+std::string RpcHttpRequest::getCodes() const {
+  return codes_;
+}
+
+void RpcHttpRequest::setCodes(const std::string &codes) {
+  codes_ = codes;
+  setParameter(std::string("Codes"), codes);
+}
+
+std::string RpcHttpRequest::getNumber() const {
+  return number_;
+}
+
+void RpcHttpRequest::setNumber(const std::string &number) {
+  number_ = number;
+  setParameter(std::string("Number"), number);
+}
+
+std::string RpcHttpRequest::getMonkey() const {
+  return monkey_;
+}
+
+void RpcHttpRequest::setMonkey(const std::string &monkey) {
+  monkey_ = monkey;
+  setParameter(std::string("Monkey"), monkey);
+}
+
+std::string RpcHttpRequest::getWorld() const {
+  return world_;
+}
+
+void RpcHttpRequest::setWorld(const std::string &world) {
+  world_ = world;
+  setParameter(std::string("World"), world);
+}
+
+std::string RpcHttpRequest::getParam() const {
+  return param_;
+}
+
+void RpcHttpRequest::setParam(const std::string &param) {
+  param_ = param;
+  setParameter(std::string("Param"), param);
+}
+
+std::string RpcHttpRequest::getOld() const {
+  return old_;
+}
+
+void RpcHttpRequest::setOld(const std::string &old) {
+  old_ = old;
+  setParameter(std::string("Old"), old);
+}
+
+std::string RpcHttpRequest::getName() const {
+  return name_;
+}
+
+void RpcHttpRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string RpcHttpRequest::getId() const {
+  return id_;
+}
+
+void RpcHttpRequest::setId(const std::string &id) {
+  id_ = id;
+  setParameter(std::string("Id"), id);
+}
+
+std::string RpcHttpRequest::getNone() const {
+  return none_;
+}
+
+void RpcHttpRequest::setNone(const std::string &none) {
+  none_ = none;
+  setParameter(std::string("None"), none);
+}
+

lmztest/src/model/RpcHttpResult.cc

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

lmztest/src/model/TestPutApiAndGetApiRequest.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/lmztest/model/TestPutApiAndGetApiRequest.h>
+
+using AlibabaCloud::LmzTest::Model::TestPutApiAndGetApiRequest;
+
+TestPutApiAndGetApiRequest::TestPutApiAndGetApiRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "TestPutApiAndGetApi") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+TestPutApiAndGetApiRequest::~TestPutApiAndGetApiRequest() {}
+

lmztest/src/model/TestPutApiAndGetApiResult.cc

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

lmztest/src/model/UpdateListenerRequest.cc

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/lmztest/model/UpdateListenerRequest.h>
+
+using AlibabaCloud::LmzTest::Model::UpdateListenerRequest;
+
+UpdateListenerRequest::UpdateListenerRequest()
+    : RpcServiceRequest("lmztest", "2010-10-11", "UpdateListener") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+UpdateListenerRequest::~UpdateListenerRequest() {}
+
+std::string UpdateListenerRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void UpdateListenerRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string UpdateListenerRequest::getDescription() const {
+  return description_;
+}
+
+void UpdateListenerRequest::setDescription(const std::string &description) {
+  description_ = description;
+  setParameter(std::string("Description"), description);
+}
+
+std::vector<UpdateListenerRequest::BackendPorts> UpdateListenerRequest::getBackendPorts() const {
+  return backendPorts_;
+}
+
+void UpdateListenerRequest::setBackendPorts(const std::vector<UpdateListenerRequest::BackendPorts> &backendPorts) {
+  backendPorts_ = backendPorts;
+  for(int dep1 = 0; dep1 != backendPorts.size(); dep1++) {
+  auto backendPortsObj = backendPorts.at(dep1);
+  std::string backendPortsObjStr = std::string("BackendPorts") + "." + std::to_string(dep1 + 1);
+    setParameter(backendPortsObjStr + ".FromPort", std::to_string(backendPortsObj.fromPort));
+    setParameter(backendPortsObjStr + ".ToPort", std::to_string(backendPortsObj.toPort));
+  }
+}
+
+std::string UpdateListenerRequest::getListenerId() const {
+  return listenerId_;
+}
+
+void UpdateListenerRequest::setListenerId(const std::string &listenerId) {
+  listenerId_ = listenerId;
+  setParameter(std::string("ListenerId"), listenerId);
+}
+
+std::string UpdateListenerRequest::getProtocol() const {
+  return protocol_;
+}
+
+void UpdateListenerRequest::setProtocol(const std::string &protocol) {
+  protocol_ = protocol;
+  setParameter(std::string("Protocol"), protocol);
+}
+
+std::string UpdateListenerRequest::getRegionId() const {
+  return regionId_;
+}
+
+void UpdateListenerRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string UpdateListenerRequest::getProxyProtocol() const {
+  return proxyProtocol_;
+}
+
+void UpdateListenerRequest::setProxyProtocol(const std::string &proxyProtocol) {
+  proxyProtocol_ = proxyProtocol;
+  setParameter(std::string("ProxyProtocol"), proxyProtocol);
+}
+
+std::vector<UpdateListenerRequest::PortRanges> UpdateListenerRequest::getPortRanges() const {
+  return portRanges_;
+}
+
+void UpdateListenerRequest::setPortRanges(const std::vector<UpdateListenerRequest::PortRanges> &portRanges) {
+  portRanges_ = portRanges;
+  for(int dep1 = 0; dep1 != portRanges.size(); dep1++) {
+  auto portRangesObj = portRanges.at(dep1);
+  std::string portRangesObjStr = std::string("PortRanges") + "." + std::to_string(dep1 + 1);
+    setParameter(portRangesObjStr + ".FromPort", std::to_string(portRangesObj.fromPort));
+    setParameter(portRangesObjStr + ".ToPort", std::to_string(portRangesObj.toPort));
+  }
+}
+
+std::vector<UpdateListenerRequest::Certificates> UpdateListenerRequest::getCertificates() const {
+  return certificates_;
+}
+
+void UpdateListenerRequest::setCertificates(const std::vector<UpdateListenerRequest::Certificates> &certificates) {
+  certificates_ = certificates;
+  for(int dep1 = 0; dep1 != certificates.size(); dep1++) {
+  auto certificatesObj = certificates.at(dep1);
+  std::string certificatesObjStr = std::string("Certificates") + "." + std::to_string(dep1 + 1);
+    setParameter(certificatesObjStr + ".Id", certificatesObj.id);
+  }
+}
+
+std::string UpdateListenerRequest::getName() const {
+  return name_;
+}
+
+void UpdateListenerRequest::setName(const std::string &name) {
+  name_ = name;
+  setParameter(std::string("Name"), name);
+}
+
+std::string UpdateListenerRequest::getClientAffinity() const {
+  return clientAffinity_;
+}
+
+void UpdateListenerRequest::setClientAffinity(const std::string &clientAffinity) {
+  clientAffinity_ = clientAffinity;
+  setParameter(std::string("ClientAffinity"), clientAffinity);
+}
+

lmztest/src/model/UpdateListenerResult.cc

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