由谦正发起的EHPC SDK自动发布, BUILD_ID=409, 版本号：1.1.0

Signed-off-by: haowei.yao <haowei.yao@alibaba-inc.com>

CHANGELOG

@@ -1,3 +1,7 @@
+2018-02-09 Version: 1.1.0
+1, Aliyun E-HPC service SDK, initial version.
+2, Include APIs of E-HPC clusters, nodes, users, jobs, job templates etc.
+
 2018-02-07 Version: 1.0.12
 1, add the access interface of logs such as vulnerabilities, baselines, exceptions, etc.
 

CMakeLists.txt

@@ -60,4 +60,5 @@ add_subdirectory(ess)
 add_subdirectory(tesladam)
 add_subdirectory(cms)
 add_subdirectory(afs)
-add_subdirectory(aegis)
+add_subdirectory(aegis)
+add_subdirectory(ehpc)

VERSION

@@ -1 +1 @@
-1.0.12
+1.1.0

ehpc/CMakeLists.txt

@@ -0,0 +1,226 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT 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(ehpc_public_header 
+	include/alibabacloud/ehpc/EHPCClient.h
+	include/alibabacloud/ehpc/EHPCExport.h )
+
+set(ehpc_public_header_model 
+	include/alibabacloud/ehpc/model/DeleteUsersRequest.h
+	include/alibabacloud/ehpc/model/DeleteUsersResult.h
+	include/alibabacloud/ehpc/model/DescribeClusterRequest.h
+	include/alibabacloud/ehpc/model/DescribeClusterResult.h
+	include/alibabacloud/ehpc/model/ListUsersRequest.h
+	include/alibabacloud/ehpc/model/ListUsersResult.h
+	include/alibabacloud/ehpc/model/UpgradeClientRequest.h
+	include/alibabacloud/ehpc/model/UpgradeClientResult.h
+	include/alibabacloud/ehpc/model/ListCurrentClientVersionRequest.h
+	include/alibabacloud/ehpc/model/ListCurrentClientVersionResult.h
+	include/alibabacloud/ehpc/model/DeleteClusterRequest.h
+	include/alibabacloud/ehpc/model/DeleteClusterResult.h
+	include/alibabacloud/ehpc/model/ListImagesRequest.h
+	include/alibabacloud/ehpc/model/ListImagesResult.h
+	include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h
+	include/alibabacloud/ehpc/model/SetAutoScaleConfigResult.h
+	include/alibabacloud/ehpc/model/ListVolumesRequest.h
+	include/alibabacloud/ehpc/model/ListVolumesResult.h
+	include/alibabacloud/ehpc/model/AddNodesRequest.h
+	include/alibabacloud/ehpc/model/AddNodesResult.h
+	include/alibabacloud/ehpc/model/ListSoftwaresRequest.h
+	include/alibabacloud/ehpc/model/ListSoftwaresResult.h
+	include/alibabacloud/ehpc/model/StopJobsRequest.h
+	include/alibabacloud/ehpc/model/StopJobsResult.h
+	include/alibabacloud/ehpc/model/GetAutoScaleConfigRequest.h
+	include/alibabacloud/ehpc/model/GetAutoScaleConfigResult.h
+	include/alibabacloud/ehpc/model/ListNodesRequest.h
+	include/alibabacloud/ehpc/model/ListNodesResult.h
+	include/alibabacloud/ehpc/model/SetJobUserRequest.h
+	include/alibabacloud/ehpc/model/SetJobUserResult.h
+	include/alibabacloud/ehpc/model/ModifyUserGroupsRequest.h
+	include/alibabacloud/ehpc/model/ModifyUserGroupsResult.h
+	include/alibabacloud/ehpc/model/ListClustersRequest.h
+	include/alibabacloud/ehpc/model/ListClustersResult.h
+	include/alibabacloud/ehpc/model/SubmitJobRequest.h
+	include/alibabacloud/ehpc/model/SubmitJobResult.h
+	include/alibabacloud/ehpc/model/ListCustomImagesRequest.h
+	include/alibabacloud/ehpc/model/ListCustomImagesResult.h
+	include/alibabacloud/ehpc/model/ListRegionsRequest.h
+	include/alibabacloud/ehpc/model/ListRegionsResult.h
+	include/alibabacloud/ehpc/model/AddUsersRequest.h
+	include/alibabacloud/ehpc/model/AddUsersResult.h
+	include/alibabacloud/ehpc/model/ListJobTemplatesRequest.h
+	include/alibabacloud/ehpc/model/ListJobTemplatesResult.h
+	include/alibabacloud/ehpc/model/ModifyClusterAttributesRequest.h
+	include/alibabacloud/ehpc/model/ModifyClusterAttributesResult.h
+	include/alibabacloud/ehpc/model/DeleteJobTemplatesRequest.h
+	include/alibabacloud/ehpc/model/DeleteJobTemplatesResult.h
+	include/alibabacloud/ehpc/model/ListNodesNoPagingRequest.h
+	include/alibabacloud/ehpc/model/ListNodesNoPagingResult.h
+	include/alibabacloud/ehpc/model/CreateJobTemplateRequest.h
+	include/alibabacloud/ehpc/model/CreateJobTemplateResult.h
+	include/alibabacloud/ehpc/model/RerunJobsRequest.h
+	include/alibabacloud/ehpc/model/RerunJobsResult.h
+	include/alibabacloud/ehpc/model/ResetNodesRequest.h
+	include/alibabacloud/ehpc/model/ResetNodesResult.h
+	include/alibabacloud/ehpc/model/EditJobTemplateRequest.h
+	include/alibabacloud/ehpc/model/EditJobTemplateResult.h
+	include/alibabacloud/ehpc/model/ListPreferredEcsTypesRequest.h
+	include/alibabacloud/ehpc/model/ListPreferredEcsTypesResult.h
+	include/alibabacloud/ehpc/model/ListClusterLogsRequest.h
+	include/alibabacloud/ehpc/model/ListClusterLogsResult.h
+	include/alibabacloud/ehpc/model/DeleteJobsRequest.h
+	include/alibabacloud/ehpc/model/DeleteJobsResult.h
+	include/alibabacloud/ehpc/model/DeleteNodesRequest.h
+	include/alibabacloud/ehpc/model/DeleteNodesResult.h
+	include/alibabacloud/ehpc/model/ListJobsRequest.h
+	include/alibabacloud/ehpc/model/ListJobsResult.h
+	include/alibabacloud/ehpc/model/CreateClusterRequest.h
+	include/alibabacloud/ehpc/model/CreateClusterResult.h
+	include/alibabacloud/ehpc/model/ModifyUserPasswordsRequest.h
+	include/alibabacloud/ehpc/model/ModifyUserPasswordsResult.h )
+
+set(ehpc_src 
+	src/EHPCClient.cc
+	src/model/DeleteUsersRequest.cc
+	src/model/DeleteUsersResult.cc
+	src/model/DescribeClusterRequest.cc
+	src/model/DescribeClusterResult.cc
+	src/model/ListUsersRequest.cc
+	src/model/ListUsersResult.cc
+	src/model/UpgradeClientRequest.cc
+	src/model/UpgradeClientResult.cc
+	src/model/ListCurrentClientVersionRequest.cc
+	src/model/ListCurrentClientVersionResult.cc
+	src/model/DeleteClusterRequest.cc
+	src/model/DeleteClusterResult.cc
+	src/model/ListImagesRequest.cc
+	src/model/ListImagesResult.cc
+	src/model/SetAutoScaleConfigRequest.cc
+	src/model/SetAutoScaleConfigResult.cc
+	src/model/ListVolumesRequest.cc
+	src/model/ListVolumesResult.cc
+	src/model/AddNodesRequest.cc
+	src/model/AddNodesResult.cc
+	src/model/ListSoftwaresRequest.cc
+	src/model/ListSoftwaresResult.cc
+	src/model/StopJobsRequest.cc
+	src/model/StopJobsResult.cc
+	src/model/GetAutoScaleConfigRequest.cc
+	src/model/GetAutoScaleConfigResult.cc
+	src/model/ListNodesRequest.cc
+	src/model/ListNodesResult.cc
+	src/model/SetJobUserRequest.cc
+	src/model/SetJobUserResult.cc
+	src/model/ModifyUserGroupsRequest.cc
+	src/model/ModifyUserGroupsResult.cc
+	src/model/ListClustersRequest.cc
+	src/model/ListClustersResult.cc
+	src/model/SubmitJobRequest.cc
+	src/model/SubmitJobResult.cc
+	src/model/ListCustomImagesRequest.cc
+	src/model/ListCustomImagesResult.cc
+	src/model/ListRegionsRequest.cc
+	src/model/ListRegionsResult.cc
+	src/model/AddUsersRequest.cc
+	src/model/AddUsersResult.cc
+	src/model/ListJobTemplatesRequest.cc
+	src/model/ListJobTemplatesResult.cc
+	src/model/ModifyClusterAttributesRequest.cc
+	src/model/ModifyClusterAttributesResult.cc
+	src/model/DeleteJobTemplatesRequest.cc
+	src/model/DeleteJobTemplatesResult.cc
+	src/model/ListNodesNoPagingRequest.cc
+	src/model/ListNodesNoPagingResult.cc
+	src/model/CreateJobTemplateRequest.cc
+	src/model/CreateJobTemplateResult.cc
+	src/model/RerunJobsRequest.cc
+	src/model/RerunJobsResult.cc
+	src/model/ResetNodesRequest.cc
+	src/model/ResetNodesResult.cc
+	src/model/EditJobTemplateRequest.cc
+	src/model/EditJobTemplateResult.cc
+	src/model/ListPreferredEcsTypesRequest.cc
+	src/model/ListPreferredEcsTypesResult.cc
+	src/model/ListClusterLogsRequest.cc
+	src/model/ListClusterLogsResult.cc
+	src/model/DeleteJobsRequest.cc
+	src/model/DeleteJobsResult.cc
+	src/model/DeleteNodesRequest.cc
+	src/model/DeleteNodesResult.cc
+	src/model/ListJobsRequest.cc
+	src/model/ListJobsResult.cc
+	src/model/CreateClusterRequest.cc
+	src/model/CreateClusterResult.cc
+	src/model/ModifyUserPasswordsRequest.cc
+	src/model/ModifyUserPasswordsResult.cc )
+
+add_library(ehpc ${LIB_TYPE}
+	${ehpc_public_header}
+	${ehpc_public_header_model}
+	${ehpc_src})
+
+set_target_properties(ehpc
+	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}ehpc
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(ehpc
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_EHPC_LIBRARY)
+endif()
+
+target_include_directories(ehpc
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(ehpc
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(ehpc
+		jsoncpp)
+	target_include_directories(ehpc
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(ehpc
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(ehpc
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(ehpc
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(ehpc
+		jsoncpp)
+endif()
+
+install(FILES ${ehpc_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/ehpc)
+install(FILES ${ehpc_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/ehpc/model)
+install(TARGETS ehpc
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

ehpc/include/alibabacloud/ehpc/EHPCClient.h

@@ -0,0 +1,335 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_EHPC_EHPCCLIENT_H_
+#define ALIBABACLOUD_EHPC_EHPCCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "EHPCExport.h"
+#include "model/DeleteUsersRequest.h"
+#include "model/DeleteUsersResult.h"
+#include "model/DescribeClusterRequest.h"
+#include "model/DescribeClusterResult.h"
+#include "model/ListUsersRequest.h"
+#include "model/ListUsersResult.h"
+#include "model/UpgradeClientRequest.h"
+#include "model/UpgradeClientResult.h"
+#include "model/ListCurrentClientVersionRequest.h"
+#include "model/ListCurrentClientVersionResult.h"
+#include "model/DeleteClusterRequest.h"
+#include "model/DeleteClusterResult.h"
+#include "model/ListImagesRequest.h"
+#include "model/ListImagesResult.h"
+#include "model/SetAutoScaleConfigRequest.h"
+#include "model/SetAutoScaleConfigResult.h"
+#include "model/ListVolumesRequest.h"
+#include "model/ListVolumesResult.h"
+#include "model/AddNodesRequest.h"
+#include "model/AddNodesResult.h"
+#include "model/ListSoftwaresRequest.h"
+#include "model/ListSoftwaresResult.h"
+#include "model/StopJobsRequest.h"
+#include "model/StopJobsResult.h"
+#include "model/GetAutoScaleConfigRequest.h"
+#include "model/GetAutoScaleConfigResult.h"
+#include "model/ListNodesRequest.h"
+#include "model/ListNodesResult.h"
+#include "model/SetJobUserRequest.h"
+#include "model/SetJobUserResult.h"
+#include "model/ModifyUserGroupsRequest.h"
+#include "model/ModifyUserGroupsResult.h"
+#include "model/ListClustersRequest.h"
+#include "model/ListClustersResult.h"
+#include "model/SubmitJobRequest.h"
+#include "model/SubmitJobResult.h"
+#include "model/ListCustomImagesRequest.h"
+#include "model/ListCustomImagesResult.h"
+#include "model/ListRegionsRequest.h"
+#include "model/ListRegionsResult.h"
+#include "model/AddUsersRequest.h"
+#include "model/AddUsersResult.h"
+#include "model/ListJobTemplatesRequest.h"
+#include "model/ListJobTemplatesResult.h"
+#include "model/ModifyClusterAttributesRequest.h"
+#include "model/ModifyClusterAttributesResult.h"
+#include "model/DeleteJobTemplatesRequest.h"
+#include "model/DeleteJobTemplatesResult.h"
+#include "model/ListNodesNoPagingRequest.h"
+#include "model/ListNodesNoPagingResult.h"
+#include "model/CreateJobTemplateRequest.h"
+#include "model/CreateJobTemplateResult.h"
+#include "model/RerunJobsRequest.h"
+#include "model/RerunJobsResult.h"
+#include "model/ResetNodesRequest.h"
+#include "model/ResetNodesResult.h"
+#include "model/EditJobTemplateRequest.h"
+#include "model/EditJobTemplateResult.h"
+#include "model/ListPreferredEcsTypesRequest.h"
+#include "model/ListPreferredEcsTypesResult.h"
+#include "model/ListClusterLogsRequest.h"
+#include "model/ListClusterLogsResult.h"
+#include "model/DeleteJobsRequest.h"
+#include "model/DeleteJobsResult.h"
+#include "model/DeleteNodesRequest.h"
+#include "model/DeleteNodesResult.h"
+#include "model/ListJobsRequest.h"
+#include "model/ListJobsResult.h"
+#include "model/CreateClusterRequest.h"
+#include "model/CreateClusterResult.h"
+#include "model/ModifyUserPasswordsRequest.h"
+#include "model/ModifyUserPasswordsResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		class ALIBABACLOUD_EHPC_EXPORT EHPCClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::DeleteUsersResult> DeleteUsersOutcome;			
+			typedef std::future<DeleteUsersOutcome> DeleteUsersOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::DeleteUsersRequest&, const DeleteUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteUsersAsyncHandler;
+			typedef Outcome<Error, Model::DescribeClusterResult> DescribeClusterOutcome;			
+			typedef std::future<DescribeClusterOutcome> DescribeClusterOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::DescribeClusterRequest&, const DescribeClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeClusterAsyncHandler;
+			typedef Outcome<Error, Model::ListUsersResult> ListUsersOutcome;			
+			typedef std::future<ListUsersOutcome> ListUsersOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListUsersRequest&, const ListUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUsersAsyncHandler;
+			typedef Outcome<Error, Model::UpgradeClientResult> UpgradeClientOutcome;			
+			typedef std::future<UpgradeClientOutcome> UpgradeClientOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::UpgradeClientRequest&, const UpgradeClientOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpgradeClientAsyncHandler;
+			typedef Outcome<Error, Model::ListCurrentClientVersionResult> ListCurrentClientVersionOutcome;			
+			typedef std::future<ListCurrentClientVersionOutcome> ListCurrentClientVersionOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListCurrentClientVersionRequest&, const ListCurrentClientVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCurrentClientVersionAsyncHandler;
+			typedef Outcome<Error, Model::DeleteClusterResult> DeleteClusterOutcome;			
+			typedef std::future<DeleteClusterOutcome> DeleteClusterOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::DeleteClusterRequest&, const DeleteClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteClusterAsyncHandler;
+			typedef Outcome<Error, Model::ListImagesResult> ListImagesOutcome;			
+			typedef std::future<ListImagesOutcome> ListImagesOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListImagesRequest&, const ListImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListImagesAsyncHandler;
+			typedef Outcome<Error, Model::SetAutoScaleConfigResult> SetAutoScaleConfigOutcome;			
+			typedef std::future<SetAutoScaleConfigOutcome> SetAutoScaleConfigOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::SetAutoScaleConfigRequest&, const SetAutoScaleConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetAutoScaleConfigAsyncHandler;
+			typedef Outcome<Error, Model::ListVolumesResult> ListVolumesOutcome;			
+			typedef std::future<ListVolumesOutcome> ListVolumesOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListVolumesRequest&, const ListVolumesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListVolumesAsyncHandler;
+			typedef Outcome<Error, Model::AddNodesResult> AddNodesOutcome;			
+			typedef std::future<AddNodesOutcome> AddNodesOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::AddNodesRequest&, const AddNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddNodesAsyncHandler;
+			typedef Outcome<Error, Model::ListSoftwaresResult> ListSoftwaresOutcome;			
+			typedef std::future<ListSoftwaresOutcome> ListSoftwaresOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListSoftwaresRequest&, const ListSoftwaresOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSoftwaresAsyncHandler;
+			typedef Outcome<Error, Model::StopJobsResult> StopJobsOutcome;			
+			typedef std::future<StopJobsOutcome> StopJobsOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::StopJobsRequest&, const StopJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopJobsAsyncHandler;
+			typedef Outcome<Error, Model::GetAutoScaleConfigResult> GetAutoScaleConfigOutcome;			
+			typedef std::future<GetAutoScaleConfigOutcome> GetAutoScaleConfigOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::GetAutoScaleConfigRequest&, const GetAutoScaleConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAutoScaleConfigAsyncHandler;
+			typedef Outcome<Error, Model::ListNodesResult> ListNodesOutcome;			
+			typedef std::future<ListNodesOutcome> ListNodesOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListNodesRequest&, const ListNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNodesAsyncHandler;
+			typedef Outcome<Error, Model::SetJobUserResult> SetJobUserOutcome;			
+			typedef std::future<SetJobUserOutcome> SetJobUserOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::SetJobUserRequest&, const SetJobUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetJobUserAsyncHandler;
+			typedef Outcome<Error, Model::ModifyUserGroupsResult> ModifyUserGroupsOutcome;			
+			typedef std::future<ModifyUserGroupsOutcome> ModifyUserGroupsOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ModifyUserGroupsRequest&, const ModifyUserGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyUserGroupsAsyncHandler;
+			typedef Outcome<Error, Model::ListClustersResult> ListClustersOutcome;			
+			typedef std::future<ListClustersOutcome> ListClustersOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListClustersRequest&, const ListClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClustersAsyncHandler;
+			typedef Outcome<Error, Model::SubmitJobResult> SubmitJobOutcome;			
+			typedef std::future<SubmitJobOutcome> SubmitJobOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::SubmitJobRequest&, const SubmitJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SubmitJobAsyncHandler;
+			typedef Outcome<Error, Model::ListCustomImagesResult> ListCustomImagesOutcome;			
+			typedef std::future<ListCustomImagesOutcome> ListCustomImagesOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListCustomImagesRequest&, const ListCustomImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCustomImagesAsyncHandler;
+			typedef Outcome<Error, Model::ListRegionsResult> ListRegionsOutcome;			
+			typedef std::future<ListRegionsOutcome> ListRegionsOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListRegionsRequest&, const ListRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRegionsAsyncHandler;
+			typedef Outcome<Error, Model::AddUsersResult> AddUsersOutcome;			
+			typedef std::future<AddUsersOutcome> AddUsersOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::AddUsersRequest&, const AddUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddUsersAsyncHandler;
+			typedef Outcome<Error, Model::ListJobTemplatesResult> ListJobTemplatesOutcome;			
+			typedef std::future<ListJobTemplatesOutcome> ListJobTemplatesOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListJobTemplatesRequest&, const ListJobTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListJobTemplatesAsyncHandler;
+			typedef Outcome<Error, Model::ModifyClusterAttributesResult> ModifyClusterAttributesOutcome;			
+			typedef std::future<ModifyClusterAttributesOutcome> ModifyClusterAttributesOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ModifyClusterAttributesRequest&, const ModifyClusterAttributesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyClusterAttributesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteJobTemplatesResult> DeleteJobTemplatesOutcome;			
+			typedef std::future<DeleteJobTemplatesOutcome> DeleteJobTemplatesOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::DeleteJobTemplatesRequest&, const DeleteJobTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteJobTemplatesAsyncHandler;
+			typedef Outcome<Error, Model::ListNodesNoPagingResult> ListNodesNoPagingOutcome;			
+			typedef std::future<ListNodesNoPagingOutcome> ListNodesNoPagingOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListNodesNoPagingRequest&, const ListNodesNoPagingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNodesNoPagingAsyncHandler;
+			typedef Outcome<Error, Model::CreateJobTemplateResult> CreateJobTemplateOutcome;			
+			typedef std::future<CreateJobTemplateOutcome> CreateJobTemplateOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::CreateJobTemplateRequest&, const CreateJobTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateJobTemplateAsyncHandler;
+			typedef Outcome<Error, Model::RerunJobsResult> RerunJobsOutcome;			
+			typedef std::future<RerunJobsOutcome> RerunJobsOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::RerunJobsRequest&, const RerunJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RerunJobsAsyncHandler;
+			typedef Outcome<Error, Model::ResetNodesResult> ResetNodesOutcome;			
+			typedef std::future<ResetNodesOutcome> ResetNodesOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ResetNodesRequest&, const ResetNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetNodesAsyncHandler;
+			typedef Outcome<Error, Model::EditJobTemplateResult> EditJobTemplateOutcome;			
+			typedef std::future<EditJobTemplateOutcome> EditJobTemplateOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::EditJobTemplateRequest&, const EditJobTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EditJobTemplateAsyncHandler;
+			typedef Outcome<Error, Model::ListPreferredEcsTypesResult> ListPreferredEcsTypesOutcome;			
+			typedef std::future<ListPreferredEcsTypesOutcome> ListPreferredEcsTypesOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListPreferredEcsTypesRequest&, const ListPreferredEcsTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListPreferredEcsTypesAsyncHandler;
+			typedef Outcome<Error, Model::ListClusterLogsResult> ListClusterLogsOutcome;			
+			typedef std::future<ListClusterLogsOutcome> ListClusterLogsOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListClusterLogsRequest&, const ListClusterLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClusterLogsAsyncHandler;
+			typedef Outcome<Error, Model::DeleteJobsResult> DeleteJobsOutcome;			
+			typedef std::future<DeleteJobsOutcome> DeleteJobsOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::DeleteJobsRequest&, const DeleteJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteJobsAsyncHandler;
+			typedef Outcome<Error, Model::DeleteNodesResult> DeleteNodesOutcome;			
+			typedef std::future<DeleteNodesOutcome> DeleteNodesOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::DeleteNodesRequest&, const DeleteNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNodesAsyncHandler;
+			typedef Outcome<Error, Model::ListJobsResult> ListJobsOutcome;			
+			typedef std::future<ListJobsOutcome> ListJobsOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ListJobsRequest&, const ListJobsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListJobsAsyncHandler;
+			typedef Outcome<Error, Model::CreateClusterResult> CreateClusterOutcome;			
+			typedef std::future<CreateClusterOutcome> CreateClusterOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::CreateClusterRequest&, const CreateClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateClusterAsyncHandler;
+			typedef Outcome<Error, Model::ModifyUserPasswordsResult> ModifyUserPasswordsOutcome;			
+			typedef std::future<ModifyUserPasswordsOutcome> ModifyUserPasswordsOutcomeCallable;			
+			typedef std::function<void(const EHPCClient*, const Model::ModifyUserPasswordsRequest&, const ModifyUserPasswordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyUserPasswordsAsyncHandler;
+
+			EHPCClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			EHPCClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			EHPCClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~EHPCClient();
+            DeleteUsersOutcome deleteUsers(const Model::DeleteUsersRequest &request)const;
+            void deleteUsersAsync(const Model::DeleteUsersRequest& request, const DeleteUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DeleteUsersOutcomeCallable deleteUsersCallable(const Model::DeleteUsersRequest& request) const;
+            DescribeClusterOutcome describeCluster(const Model::DescribeClusterRequest &request)const;
+            void describeClusterAsync(const Model::DescribeClusterRequest& request, const DescribeClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DescribeClusterOutcomeCallable describeClusterCallable(const Model::DescribeClusterRequest& request) const;
+            ListUsersOutcome listUsers(const Model::ListUsersRequest &request)const;
+            void listUsersAsync(const Model::ListUsersRequest& request, const ListUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListUsersOutcomeCallable listUsersCallable(const Model::ListUsersRequest& request) const;
+            UpgradeClientOutcome upgradeClient(const Model::UpgradeClientRequest &request)const;
+            void upgradeClientAsync(const Model::UpgradeClientRequest& request, const UpgradeClientAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            UpgradeClientOutcomeCallable upgradeClientCallable(const Model::UpgradeClientRequest& request) const;
+            ListCurrentClientVersionOutcome listCurrentClientVersion(const Model::ListCurrentClientVersionRequest &request)const;
+            void listCurrentClientVersionAsync(const Model::ListCurrentClientVersionRequest& request, const ListCurrentClientVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListCurrentClientVersionOutcomeCallable listCurrentClientVersionCallable(const Model::ListCurrentClientVersionRequest& request) const;
+            DeleteClusterOutcome deleteCluster(const Model::DeleteClusterRequest &request)const;
+            void deleteClusterAsync(const Model::DeleteClusterRequest& request, const DeleteClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DeleteClusterOutcomeCallable deleteClusterCallable(const Model::DeleteClusterRequest& request) const;
+            ListImagesOutcome listImages(const Model::ListImagesRequest &request)const;
+            void listImagesAsync(const Model::ListImagesRequest& request, const ListImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListImagesOutcomeCallable listImagesCallable(const Model::ListImagesRequest& request) const;
+            SetAutoScaleConfigOutcome setAutoScaleConfig(const Model::SetAutoScaleConfigRequest &request)const;
+            void setAutoScaleConfigAsync(const Model::SetAutoScaleConfigRequest& request, const SetAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            SetAutoScaleConfigOutcomeCallable setAutoScaleConfigCallable(const Model::SetAutoScaleConfigRequest& request) const;
+            ListVolumesOutcome listVolumes(const Model::ListVolumesRequest &request)const;
+            void listVolumesAsync(const Model::ListVolumesRequest& request, const ListVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListVolumesOutcomeCallable listVolumesCallable(const Model::ListVolumesRequest& request) const;
+            AddNodesOutcome addNodes(const Model::AddNodesRequest &request)const;
+            void addNodesAsync(const Model::AddNodesRequest& request, const AddNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            AddNodesOutcomeCallable addNodesCallable(const Model::AddNodesRequest& request) const;
+            ListSoftwaresOutcome listSoftwares(const Model::ListSoftwaresRequest &request)const;
+            void listSoftwaresAsync(const Model::ListSoftwaresRequest& request, const ListSoftwaresAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListSoftwaresOutcomeCallable listSoftwaresCallable(const Model::ListSoftwaresRequest& request) const;
+            StopJobsOutcome stopJobs(const Model::StopJobsRequest &request)const;
+            void stopJobsAsync(const Model::StopJobsRequest& request, const StopJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            StopJobsOutcomeCallable stopJobsCallable(const Model::StopJobsRequest& request) const;
+            GetAutoScaleConfigOutcome getAutoScaleConfig(const Model::GetAutoScaleConfigRequest &request)const;
+            void getAutoScaleConfigAsync(const Model::GetAutoScaleConfigRequest& request, const GetAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            GetAutoScaleConfigOutcomeCallable getAutoScaleConfigCallable(const Model::GetAutoScaleConfigRequest& request) const;
+            ListNodesOutcome listNodes(const Model::ListNodesRequest &request)const;
+            void listNodesAsync(const Model::ListNodesRequest& request, const ListNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListNodesOutcomeCallable listNodesCallable(const Model::ListNodesRequest& request) const;
+            SetJobUserOutcome setJobUser(const Model::SetJobUserRequest &request)const;
+            void setJobUserAsync(const Model::SetJobUserRequest& request, const SetJobUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            SetJobUserOutcomeCallable setJobUserCallable(const Model::SetJobUserRequest& request) const;
+            ModifyUserGroupsOutcome modifyUserGroups(const Model::ModifyUserGroupsRequest &request)const;
+            void modifyUserGroupsAsync(const Model::ModifyUserGroupsRequest& request, const ModifyUserGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ModifyUserGroupsOutcomeCallable modifyUserGroupsCallable(const Model::ModifyUserGroupsRequest& request) const;
+            ListClustersOutcome listClusters(const Model::ListClustersRequest &request)const;
+            void listClustersAsync(const Model::ListClustersRequest& request, const ListClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListClustersOutcomeCallable listClustersCallable(const Model::ListClustersRequest& request) const;
+            SubmitJobOutcome submitJob(const Model::SubmitJobRequest &request)const;
+            void submitJobAsync(const Model::SubmitJobRequest& request, const SubmitJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            SubmitJobOutcomeCallable submitJobCallable(const Model::SubmitJobRequest& request) const;
+            ListCustomImagesOutcome listCustomImages(const Model::ListCustomImagesRequest &request)const;
+            void listCustomImagesAsync(const Model::ListCustomImagesRequest& request, const ListCustomImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListCustomImagesOutcomeCallable listCustomImagesCallable(const Model::ListCustomImagesRequest& request) const;
+            ListRegionsOutcome listRegions(const Model::ListRegionsRequest &request)const;
+            void listRegionsAsync(const Model::ListRegionsRequest& request, const ListRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListRegionsOutcomeCallable listRegionsCallable(const Model::ListRegionsRequest& request) const;
+            AddUsersOutcome addUsers(const Model::AddUsersRequest &request)const;
+            void addUsersAsync(const Model::AddUsersRequest& request, const AddUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            AddUsersOutcomeCallable addUsersCallable(const Model::AddUsersRequest& request) const;
+            ListJobTemplatesOutcome listJobTemplates(const Model::ListJobTemplatesRequest &request)const;
+            void listJobTemplatesAsync(const Model::ListJobTemplatesRequest& request, const ListJobTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListJobTemplatesOutcomeCallable listJobTemplatesCallable(const Model::ListJobTemplatesRequest& request) const;
+            ModifyClusterAttributesOutcome modifyClusterAttributes(const Model::ModifyClusterAttributesRequest &request)const;
+            void modifyClusterAttributesAsync(const Model::ModifyClusterAttributesRequest& request, const ModifyClusterAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ModifyClusterAttributesOutcomeCallable modifyClusterAttributesCallable(const Model::ModifyClusterAttributesRequest& request) const;
+            DeleteJobTemplatesOutcome deleteJobTemplates(const Model::DeleteJobTemplatesRequest &request)const;
+            void deleteJobTemplatesAsync(const Model::DeleteJobTemplatesRequest& request, const DeleteJobTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DeleteJobTemplatesOutcomeCallable deleteJobTemplatesCallable(const Model::DeleteJobTemplatesRequest& request) const;
+            ListNodesNoPagingOutcome listNodesNoPaging(const Model::ListNodesNoPagingRequest &request)const;
+            void listNodesNoPagingAsync(const Model::ListNodesNoPagingRequest& request, const ListNodesNoPagingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListNodesNoPagingOutcomeCallable listNodesNoPagingCallable(const Model::ListNodesNoPagingRequest& request) const;
+            CreateJobTemplateOutcome createJobTemplate(const Model::CreateJobTemplateRequest &request)const;
+            void createJobTemplateAsync(const Model::CreateJobTemplateRequest& request, const CreateJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            CreateJobTemplateOutcomeCallable createJobTemplateCallable(const Model::CreateJobTemplateRequest& request) const;
+            RerunJobsOutcome rerunJobs(const Model::RerunJobsRequest &request)const;
+            void rerunJobsAsync(const Model::RerunJobsRequest& request, const RerunJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            RerunJobsOutcomeCallable rerunJobsCallable(const Model::RerunJobsRequest& request) const;
+            ResetNodesOutcome resetNodes(const Model::ResetNodesRequest &request)const;
+            void resetNodesAsync(const Model::ResetNodesRequest& request, const ResetNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ResetNodesOutcomeCallable resetNodesCallable(const Model::ResetNodesRequest& request) const;
+            EditJobTemplateOutcome editJobTemplate(const Model::EditJobTemplateRequest &request)const;
+            void editJobTemplateAsync(const Model::EditJobTemplateRequest& request, const EditJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            EditJobTemplateOutcomeCallable editJobTemplateCallable(const Model::EditJobTemplateRequest& request) const;
+            ListPreferredEcsTypesOutcome listPreferredEcsTypes(const Model::ListPreferredEcsTypesRequest &request)const;
+            void listPreferredEcsTypesAsync(const Model::ListPreferredEcsTypesRequest& request, const ListPreferredEcsTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListPreferredEcsTypesOutcomeCallable listPreferredEcsTypesCallable(const Model::ListPreferredEcsTypesRequest& request) const;
+            ListClusterLogsOutcome listClusterLogs(const Model::ListClusterLogsRequest &request)const;
+            void listClusterLogsAsync(const Model::ListClusterLogsRequest& request, const ListClusterLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListClusterLogsOutcomeCallable listClusterLogsCallable(const Model::ListClusterLogsRequest& request) const;
+            DeleteJobsOutcome deleteJobs(const Model::DeleteJobsRequest &request)const;
+            void deleteJobsAsync(const Model::DeleteJobsRequest& request, const DeleteJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DeleteJobsOutcomeCallable deleteJobsCallable(const Model::DeleteJobsRequest& request) const;
+            DeleteNodesOutcome deleteNodes(const Model::DeleteNodesRequest &request)const;
+            void deleteNodesAsync(const Model::DeleteNodesRequest& request, const DeleteNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            DeleteNodesOutcomeCallable deleteNodesCallable(const Model::DeleteNodesRequest& request) const;
+            ListJobsOutcome listJobs(const Model::ListJobsRequest &request)const;
+            void listJobsAsync(const Model::ListJobsRequest& request, const ListJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ListJobsOutcomeCallable listJobsCallable(const Model::ListJobsRequest& request) const;
+            CreateClusterOutcome createCluster(const Model::CreateClusterRequest &request)const;
+            void createClusterAsync(const Model::CreateClusterRequest& request, const CreateClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            CreateClusterOutcomeCallable createClusterCallable(const Model::CreateClusterRequest& request) const;
+            ModifyUserPasswordsOutcome modifyUserPasswords(const Model::ModifyUserPasswordsRequest &request)const;
+            void modifyUserPasswordsAsync(const Model::ModifyUserPasswordsRequest& request, const ModifyUserPasswordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+            ModifyUserPasswordsOutcomeCallable modifyUserPasswordsCallable(const Model::ModifyUserPasswordsRequest& request) const;
+	
+		private:
+			virtual EndpointOutcome endpoint()const override;
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_EHPC_EHPCCLIENT_H_

ehpc/include/alibabacloud/ehpc/EHPCExport.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_EHPC_EHPCEXPORT_H_
+#define ALIBABACLOUD_EHPC_EHPCEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_EHPC_LIBRARY)
+#		define ALIBABACLOUD_EHPC_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_EHPC_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_EHPC_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_EHPC_EHPCEXPORT_H_

ehpc/include/alibabacloud/ehpc/model/AddNodesRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_ADDNODESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDNODESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT AddNodesRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddNodesRequest();
+				~AddNodesRequest();
+
+				std::string getImageId()const;
+				void setImageId(const std::string& imageId);
+				int getCount()const;
+				void setCount(int count);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getComputeSpotStrategy()const;
+				void setComputeSpotStrategy(const std::string& computeSpotStrategy);
+				std::string getComputeSpotPriceLimit()const;
+				void setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getImageOwnerAlias()const;
+				void setImageOwnerAlias(const std::string& imageOwnerAlias);
+
+            private:
+				std::string imageId_;
+				int count_;
+				std::string clusterId_;
+				std::string computeSpotStrategy_;
+				std::string computeSpotPriceLimit_;
+				std::string accessKeyId_;
+				std::string imageOwnerAlias_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDNODESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/AddNodesResult.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_EHPC_MODEL_ADDNODESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDNODESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT AddNodesResult : public ServiceResult
+			{
+			public:
+
+
+				AddNodesResult();
+				explicit AddNodesResult(const std::string &payload);
+				~AddNodesResult();
+				std::vector<std::string> getInstanceIds()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> instanceIds_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDNODESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/AddUsersRequest.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_EHPC_MODEL_ADDUSERSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDUSERSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT AddUsersRequest : public RpcServiceRequest
+			{
+				struct User
+				{
+					std::string name;
+					std::string group;
+					std::string password;
+				};
+
+			public:
+				AddUsersRequest();
+				~AddUsersRequest();
+
+				bool getReleaseInstance()const;
+				void setReleaseInstance(bool releaseInstance);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::vector<User> getUser()const;
+				void setUser(const std::vector<User>& user);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				bool releaseInstance_;
+				std::string clusterId_;
+				std::vector<User> user_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDUSERSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/AddUsersResult.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_EHPC_MODEL_ADDUSERSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDUSERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT AddUsersResult : public ServiceResult
+			{
+			public:
+
+
+				AddUsersResult();
+				explicit AddUsersResult(const std::string &payload);
+				~AddUsersResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDUSERSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/CreateClusterRequest.h

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_EHPC_MODEL_CREATECLUSTERREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATECLUSTERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT CreateClusterRequest : public RpcServiceRequest
+			{
+				struct Application
+				{
+					std::string tag;
+				};
+
+			public:
+				CreateClusterRequest();
+				~CreateClusterRequest();
+
+				std::string getSccClusterId()const;
+				void setSccClusterId(const std::string& sccClusterId);
+				std::string getImageId()const;
+				void setImageId(const std::string& imageId);
+				std::string getEcsOrderManagerInstanceType()const;
+				void setEcsOrderManagerInstanceType(const std::string& ecsOrderManagerInstanceType);
+				std::string getEhpcVersion()const;
+				void setEhpcVersion(const std::string& ehpcVersion);
+				std::string getAccountType()const;
+				void setAccountType(const std::string& accountType);
+				std::string getSecurityGroupId()const;
+				void setSecurityGroupId(const std::string& securityGroupId);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getKeyPairName()const;
+				void setKeyPairName(const std::string& keyPairName);
+				std::string getSecurityGroupName()const;
+				void setSecurityGroupName(const std::string& securityGroupName);
+				std::string getEcsOrderComputeInstanceType()const;
+				void setEcsOrderComputeInstanceType(const std::string& ecsOrderComputeInstanceType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getImageOwnerAlias()const;
+				void setImageOwnerAlias(const std::string& imageOwnerAlias);
+				std::string getVolumeType()const;
+				void setVolumeType(const std::string& volumeType);
+				int getEcsOrderManagerCount()const;
+				void setEcsOrderManagerCount(int ecsOrderManagerCount);
+				std::string getPassword()const;
+				void setPassword(const std::string& password);
+				int getEcsOrderLoginCount()const;
+				void setEcsOrderLoginCount(int ecsOrderLoginCount);
+				std::string getComputeSpotPriceLimit()const;
+				void setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit);
+				std::string getVolumeProtocol()const;
+				void setVolumeProtocol(const std::string& volumeProtocol);
+				std::string getOsTag()const;
+				void setOsTag(const std::string& osTag);
+				std::string getRemoteDirectory()const;
+				void setRemoteDirectory(const std::string& remoteDirectory);
+				int getEcsOrderComputeCount()const;
+				void setEcsOrderComputeCount(int ecsOrderComputeCount);
+				std::string getComputeSpotStrategy()const;
+				void setComputeSpotStrategy(const std::string& computeSpotStrategy);
+				std::string getVSwitchId()const;
+				void setVSwitchId(const std::string& vSwitchId);
+				std::vector<Application> getApplication()const;
+				void setApplication(const std::vector<Application>& application);
+				std::string getEcsChargeType()const;
+				void setEcsChargeType(const std::string& ecsChargeType);
+				bool getHaEnable()const;
+				void setHaEnable(bool haEnable);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getSchedulerType()const;
+				void setSchedulerType(const std::string& schedulerType);
+				std::string getVolumeId()const;
+				void setVolumeId(const std::string& volumeId);
+				std::string getVolumeMountpoint()const;
+				void setVolumeMountpoint(const std::string& volumeMountpoint);
+				std::string getEcsOrderLoginInstanceType()const;
+				void setEcsOrderLoginInstanceType(const std::string& ecsOrderLoginInstanceType);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+
+            private:
+				std::string sccClusterId_;
+				std::string imageId_;
+				std::string ecsOrderManagerInstanceType_;
+				std::string ehpcVersion_;
+				std::string accountType_;
+				std::string securityGroupId_;
+				std::string description_;
+				std::string keyPairName_;
+				std::string securityGroupName_;
+				std::string ecsOrderComputeInstanceType_;
+				std::string accessKeyId_;
+				std::string imageOwnerAlias_;
+				std::string volumeType_;
+				int ecsOrderManagerCount_;
+				std::string password_;
+				int ecsOrderLoginCount_;
+				std::string computeSpotPriceLimit_;
+				std::string volumeProtocol_;
+				std::string osTag_;
+				std::string remoteDirectory_;
+				int ecsOrderComputeCount_;
+				std::string computeSpotStrategy_;
+				std::string vSwitchId_;
+				std::vector<Application> application_;
+				std::string ecsChargeType_;
+				bool haEnable_;
+				std::string name_;
+				std::string schedulerType_;
+				std::string volumeId_;
+				std::string volumeMountpoint_;
+				std::string ecsOrderLoginInstanceType_;
+				std::string zoneId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATECLUSTERREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/CreateClusterResult.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_EHPC_MODEL_CREATECLUSTERRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATECLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT CreateClusterResult : public ServiceResult
+			{
+			public:
+
+
+				CreateClusterResult();
+				explicit CreateClusterResult(const std::string &payload);
+				~CreateClusterResult();
+				std::string getClusterId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATECLUSTERRESULT_H_

ehpc/include/alibabacloud/ehpc/model/CreateJobTemplateRequest.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_CREATEJOBTEMPLATEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEJOBTEMPLATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT CreateJobTemplateRequest : public RpcServiceRequest
+			{
+
+			public:
+				CreateJobTemplateRequest();
+				~CreateJobTemplateRequest();
+
+				std::string getStderrRedirectPath()const;
+				void setStderrRedirectPath(const std::string& stderrRedirectPath);
+				std::string getVariables()const;
+				void setVariables(const std::string& variables);
+				std::string getRunasUser()const;
+				void setRunasUser(const std::string& runasUser);
+				bool getReRunable()const;
+				void setReRunable(bool reRunable);
+				int getPriority()const;
+				void setPriority(int priority);
+				std::string getCommandLine()const;
+				void setCommandLine(const std::string& commandLine);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getArrayRequest()const;
+				void setArrayRequest(const std::string& arrayRequest);
+				std::string getPackagePath()const;
+				void setPackagePath(const std::string& packagePath);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getStdoutRedirectPath()const;
+				void setStdoutRedirectPath(const std::string& stdoutRedirectPath);
+
+            private:
+				std::string stderrRedirectPath_;
+				std::string variables_;
+				std::string runasUser_;
+				bool reRunable_;
+				int priority_;
+				std::string commandLine_;
+				std::string accessKeyId_;
+				std::string arrayRequest_;
+				std::string packagePath_;
+				std::string regionId_;
+				std::string name_;
+				std::string stdoutRedirectPath_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEJOBTEMPLATEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/CreateJobTemplateResult.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_EHPC_MODEL_CREATEJOBTEMPLATERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEJOBTEMPLATERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT CreateJobTemplateResult : public ServiceResult
+			{
+			public:
+
+
+				CreateJobTemplateResult();
+				explicit CreateJobTemplateResult(const std::string &payload);
+				~CreateJobTemplateResult();
+				std::string getTemplateId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string templateId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEJOBTEMPLATERESULT_H_

ehpc/include/alibabacloud/ehpc/model/DeleteClusterRequest.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_EHPC_MODEL_DELETECLUSTERREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETECLUSTERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DeleteClusterRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteClusterRequest();
+				~DeleteClusterRequest();
+
+				std::string getReleaseInstance()const;
+				void setReleaseInstance(const std::string& releaseInstance);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string releaseInstance_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETECLUSTERREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DeleteClusterResult.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_EHPC_MODEL_DELETECLUSTERRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETECLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DeleteClusterResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteClusterResult();
+				explicit DeleteClusterResult(const std::string &payload);
+				~DeleteClusterResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETECLUSTERRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DeleteJobTemplatesRequest.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_EHPC_MODEL_DELETEJOBTEMPLATESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEJOBTEMPLATESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DeleteJobTemplatesRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteJobTemplatesRequest();
+				~DeleteJobTemplatesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getTemplates()const;
+				void setTemplates(const std::string& templates);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string regionId_;
+				std::string templates_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEJOBTEMPLATESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DeleteJobTemplatesResult.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_EHPC_MODEL_DELETEJOBTEMPLATESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEJOBTEMPLATESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DeleteJobTemplatesResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteJobTemplatesResult();
+				explicit DeleteJobTemplatesResult(const std::string &payload);
+				~DeleteJobTemplatesResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEJOBTEMPLATESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DeleteJobsRequest.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_EHPC_MODEL_DELETEJOBSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEJOBSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DeleteJobsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteJobsRequest();
+				~DeleteJobsRequest();
+
+				std::string getJobs()const;
+				void setJobs(const std::string& jobs);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string jobs_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEJOBSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DeleteJobsResult.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_EHPC_MODEL_DELETEJOBSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEJOBSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DeleteJobsResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteJobsResult();
+				explicit DeleteJobsResult(const std::string &payload);
+				~DeleteJobsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEJOBSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DeleteNodesRequest.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_EHPC_MODEL_DELETENODESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETENODESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DeleteNodesRequest : public RpcServiceRequest
+			{
+				struct Instance
+				{
+					std::string id;
+				};
+
+			public:
+				DeleteNodesRequest();
+				~DeleteNodesRequest();
+
+				bool getReleaseInstance()const;
+				void setReleaseInstance(bool releaseInstance);
+				std::vector<Instance> getInstance()const;
+				void setInstance(const std::vector<Instance>& instance);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				bool releaseInstance_;
+				std::vector<Instance> instance_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETENODESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DeleteNodesResult.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_EHPC_MODEL_DELETENODESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETENODESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DeleteNodesResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteNodesResult();
+				explicit DeleteNodesResult(const std::string &payload);
+				~DeleteNodesResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETENODESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DeleteUsersRequest.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_EHPC_MODEL_DELETEUSERSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEUSERSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DeleteUsersRequest : public RpcServiceRequest
+			{
+				struct User
+				{
+					std::string name;
+				};
+
+			public:
+				DeleteUsersRequest();
+				~DeleteUsersRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::vector<User> getUser()const;
+				void setUser(const std::vector<User>& user);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string clusterId_;
+				std::vector<User> user_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEUSERSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DeleteUsersResult.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_EHPC_MODEL_DELETEUSERSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEUSERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DeleteUsersResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteUsersResult();
+				explicit DeleteUsersResult(const std::string &payload);
+				~DeleteUsersResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEUSERSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribeClusterRequest.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_EHPC_MODEL_DESCRIBECLUSTERREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBECLUSTERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DescribeClusterRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeClusterRequest();
+				~DescribeClusterRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBECLUSTERREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DescribeClusterResult.h

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_EHPC_MODEL_DESCRIBECLUSTERRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBECLUSTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT DescribeClusterResult : public ServiceResult
+			{
+			public:
+				struct ClusterInfo
+				{
+					struct EcsInfo
+					{
+						struct Manager
+						{
+							int count;
+							std::string instanceType;
+						};
+						struct Compute
+						{
+							int count;
+							std::string instanceType;
+						};
+						struct Login
+						{
+							int count;
+							std::string instanceType;
+						};
+						std::vector<Compute> compute;
+						std::vector<Login> login;
+						std::vector<Manager> manager;
+					};
+					struct ApplicationInfoItem
+					{
+						std::string version;
+						std::string tag;
+						std::string name;
+					};
+					std::string volumeProtocol;
+					std::string imageOwnerAlias;
+					std::string description;
+					std::vector<ApplicationInfoItem> applicationInfo;
+					std::string clientVersion;
+					std::string name;
+					std::string volumeId;
+					std::string volumeType;
+					std::string imageId;
+					std::string status;
+					std::string keyPairName;
+					std::string remoteDirectory;
+					std::string sccClusterId;
+					std::string createTime;
+					std::string securityGroupId;
+					std::string vSwitchId;
+					std::string schedulerType;
+					std::string accountType;
+					std::string volumeMountpoint;
+					std::vector<EcsInfo> ecsInfo;
+					bool haEnable;
+					std::string osTag;
+					std::string id;
+					std::string regionId;
+					std::string ecsChargeType;
+				};
+
+
+				DescribeClusterResult();
+				explicit DescribeClusterResult(const std::string &payload);
+				~DescribeClusterResult();
+				std::vector<ClusterInfo> getClusterInfo()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<ClusterInfo> clusterInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBECLUSTERRESULT_H_

ehpc/include/alibabacloud/ehpc/model/EditJobTemplateRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_EDITJOBTEMPLATEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_EDITJOBTEMPLATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT EditJobTemplateRequest : public RpcServiceRequest
+			{
+
+			public:
+				EditJobTemplateRequest();
+				~EditJobTemplateRequest();
+
+				std::string getStderrRedirectPath()const;
+				void setStderrRedirectPath(const std::string& stderrRedirectPath);
+				std::string getVariables()const;
+				void setVariables(const std::string& variables);
+				std::string getRunasUser()const;
+				void setRunasUser(const std::string& runasUser);
+				std::string getTemplateId()const;
+				void setTemplateId(const std::string& templateId);
+				int getPriority()const;
+				void setPriority(int priority);
+				std::string getCommandLine()const;
+				void setCommandLine(const std::string& commandLine);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getArrayRequest()const;
+				void setArrayRequest(const std::string& arrayRequest);
+				std::string getPackagePath()const;
+				void setPackagePath(const std::string& packagePath);
+				bool getReRunnable()const;
+				void setReRunnable(bool reRunnable);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getStdoutRedirectPath()const;
+				void setStdoutRedirectPath(const std::string& stdoutRedirectPath);
+
+            private:
+				std::string stderrRedirectPath_;
+				std::string variables_;
+				std::string runasUser_;
+				std::string templateId_;
+				int priority_;
+				std::string commandLine_;
+				std::string accessKeyId_;
+				std::string arrayRequest_;
+				std::string packagePath_;
+				bool reRunnable_;
+				std::string regionId_;
+				std::string name_;
+				std::string stdoutRedirectPath_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_EDITJOBTEMPLATEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/EditJobTemplateResult.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_EHPC_MODEL_EDITJOBTEMPLATERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_EDITJOBTEMPLATERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT EditJobTemplateResult : public ServiceResult
+			{
+			public:
+
+
+				EditJobTemplateResult();
+				explicit EditJobTemplateResult(const std::string &payload);
+				~EditJobTemplateResult();
+				std::string getTemplateId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string templateId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_EDITJOBTEMPLATERESULT_H_

ehpc/include/alibabacloud/ehpc/model/GetAutoScaleConfigRequest.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_EHPC_MODEL_GETAUTOSCALECONFIGREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETAUTOSCALECONFIGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT GetAutoScaleConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAutoScaleConfigRequest();
+				~GetAutoScaleConfigRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETAUTOSCALECONFIGREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetAutoScaleConfigResult.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETAUTOSCALECONFIGRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETAUTOSCALECONFIGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT GetAutoScaleConfigResult : public ServiceResult
+			{
+			public:
+
+
+				GetAutoScaleConfigResult();
+				explicit GetAutoScaleConfigResult(const std::string &payload);
+				~GetAutoScaleConfigResult();
+				int getExtraNodesGrowRatio()const;
+				bool getEnableAutoGrow()const;
+				std::string getClusterId()const;
+				int getShrinkIdleTimes()const;
+				int getMaxNodesInCluster()const;
+				std::string getClusterType()const;
+				bool getEnableAutoShrink()const;
+				int getGrowRatio()const;
+				int getGrowIntervalInMinutes()const;
+				std::string getUid()const;
+				int getGrowTimeoutInMinutes()const;
+				int getShrinkIntervalInMinutes()const;
+				std::string getExcludeNodes()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int extraNodesGrowRatio_;
+				bool enableAutoGrow_;
+				std::string clusterId_;
+				int shrinkIdleTimes_;
+				int maxNodesInCluster_;
+				std::string clusterType_;
+				bool enableAutoShrink_;
+				int growRatio_;
+				int growIntervalInMinutes_;
+				std::string uid_;
+				int growTimeoutInMinutes_;
+				int shrinkIntervalInMinutes_;
+				std::string excludeNodes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETAUTOSCALECONFIGRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListClusterLogsRequest.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_EHPC_MODEL_LISTCLUSTERLOGSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERLOGSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListClusterLogsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListClusterLogsRequest();
+				~ListClusterLogsRequest();
+
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				int pageSize_;
+				std::string clusterId_;
+				int pageNumber_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERLOGSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListClusterLogsResult.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERLOGSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERLOGSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListClusterLogsResult : public ServiceResult
+			{
+			public:
+				struct LogInfo
+				{
+					std::string message;
+					std::string createTime;
+					std::string level;
+					std::string operation;
+				};
+
+
+				ListClusterLogsResult();
+				explicit ListClusterLogsResult(const std::string &payload);
+				~ListClusterLogsResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::string getClusterId()const;
+				std::vector<LogInfo> getLogs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::string clusterId_;
+				std::vector<LogInfo> logs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERLOGSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListClustersRequest.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_EHPC_MODEL_LISTCLUSTERSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListClustersRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListClustersRequest();
+				~ListClustersRequest();
+
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				int pageSize_;
+				int pageNumber_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListClustersResult.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_EHPC_MODEL_LISTCLUSTERSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListClustersResult : public ServiceResult
+			{
+			public:
+				struct ClusterInfoSimple
+				{
+					struct Managers
+					{
+						int normalCount;
+						int total;
+						int exceptionCount;
+					};
+					struct Computes
+					{
+						int normalCount;
+						int total;
+						int exceptionCount;
+					};
+					struct TotalResources
+					{
+						int memory;
+						int cpu;
+						int gpu;
+					};
+					struct UsedResources
+					{
+						int memory;
+						int cpu;
+						int gpu;
+					};
+					std::string status;
+					std::string imageOwnerAlias;
+					std::string description;
+					std::string zoneId;
+					std::string createTime;
+					std::string schedulerType;
+					int count;
+					std::string accountType;
+					std::string name;
+					std::vector<UsedResources> usedResources;
+					std::vector<Managers> managers;
+					std::vector<TotalResources> totalResources;
+					std::string osTag;
+					std::string imageId;
+					std::string id;
+					std::string regionId;
+					std::string instanceType;
+					std::string loginNodes;
+					std::vector<Computes> computes;
+				};
+
+
+				ListClustersResult();
+				explicit ListClustersResult(const std::string &payload);
+				~ListClustersResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<ClusterInfoSimple> getClusters()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ClusterInfoSimple> clusters_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTCLUSTERSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListCurrentClientVersionRequest.h

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

ehpc/include/alibabacloud/ehpc/model/ListCurrentClientVersionResult.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_EHPC_MODEL_LISTCURRENTCLIENTVERSIONRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTCURRENTCLIENTVERSIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListCurrentClientVersionResult : public ServiceResult
+			{
+			public:
+
+
+				ListCurrentClientVersionResult();
+				explicit ListCurrentClientVersionResult(const std::string &payload);
+				~ListCurrentClientVersionResult();
+				std::string getClientVersion()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string clientVersion_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTCURRENTCLIENTVERSIONRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListCustomImagesRequest.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_EHPC_MODEL_LISTCUSTOMIMAGESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTCUSTOMIMAGESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListCustomImagesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListCustomImagesRequest();
+				~ListCustomImagesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getBaseOsTag()const;
+				void setBaseOsTag(const std::string& baseOsTag);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getImageOwnerAlias()const;
+				void setImageOwnerAlias(const std::string& imageOwnerAlias);
+
+            private:
+				std::string regionId_;
+				std::string baseOsTag_;
+				std::string accessKeyId_;
+				std::string imageOwnerAlias_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTCUSTOMIMAGESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListCustomImagesResult.h

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

ehpc/include/alibabacloud/ehpc/model/ListImagesRequest.h

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

ehpc/include/alibabacloud/ehpc/model/ListImagesResult.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_EHPC_MODEL_LISTIMAGESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTIMAGESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListImagesResult : public ServiceResult
+			{
+			public:
+				struct OsInfo
+				{
+					std::string platform;
+					std::string architecture;
+					std::string version;
+					std::string osTag;
+				};
+
+
+				ListImagesResult();
+				explicit ListImagesResult(const std::string &payload);
+				~ListImagesResult();
+				std::vector<OsInfo> getOsTags()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<OsInfo> osTags_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTIMAGESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListJobTemplatesRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_LISTJOBTEMPLATESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTJOBTEMPLATESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListJobTemplatesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListJobTemplatesRequest();
+				~ListJobTemplatesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getName()const;
+				void setName(const std::string& name);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string regionId_;
+				std::string name_;
+				int pageSize_;
+				int pageNumber_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTJOBTEMPLATESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListJobTemplatesResult.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_EHPC_MODEL_LISTJOBTEMPLATESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTJOBTEMPLATESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListJobTemplatesResult : public ServiceResult
+			{
+			public:
+				struct JobTemplates
+				{
+					std::string variables;
+					bool reRunable;
+					std::string commandLine;
+					int priority;
+					std::string stderrRedirectPath;
+					std::string stdoutRedirectPath;
+					std::string id;
+					std::string package;
+					std::string arrayRequest;
+					std::string runasUser;
+					std::string name;
+				};
+
+
+				ListJobTemplatesResult();
+				explicit ListJobTemplatesResult(const std::string &payload);
+				~ListJobTemplatesResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<JobTemplates> getTemplates()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<JobTemplates> templates_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTJOBTEMPLATESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListJobsRequest.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_EHPC_MODEL_LISTJOBSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTJOBSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListJobsRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListJobsRequest();
+				~ListJobsRequest();
+
+				std::string getOwner()const;
+				void setOwner(const std::string& owner);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getState()const;
+				void setState(const std::string& state);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string owner_;
+				int pageSize_;
+				std::string clusterId_;
+				std::string state_;
+				int pageNumber_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTJOBSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListJobsResult.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_LISTJOBSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTJOBSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListJobsResult : public ServiceResult
+			{
+			public:
+				struct JobInfo
+				{
+					struct Resources
+					{
+						int cores;
+						int nodes;
+					};
+					std::string comment;
+					std::string owner;
+					int priority;
+					std::string startTime;
+					std::string lastModifyTime;
+					std::string submitTime;
+					std::string name;
+					std::string stderr;
+					std::string state;
+					std::vector<Resources> resources;
+					std::string id;
+					std::string arrayRequest;
+					std::string stdout;
+				};
+
+
+				ListJobsResult();
+				explicit ListJobsResult(const std::string &payload);
+				~ListJobsResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				std::vector<JobInfo> getJobs()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				std::vector<JobInfo> jobs_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTJOBSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListNodesNoPagingRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_LISTNODESNOPAGINGREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTNODESNOPAGINGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListNodesNoPagingRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListNodesNoPagingRequest();
+				~ListNodesNoPagingRequest();
+
+				std::string getHostName()const;
+				void setHostName(const std::string& hostName);
+				std::string getRole()const;
+				void setRole(const std::string& role);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				bool getOnlyDetached()const;
+				void setOnlyDetached(bool onlyDetached);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string hostName_;
+				std::string role_;
+				std::string clusterId_;
+				bool onlyDetached_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTNODESNOPAGINGREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListNodesNoPagingResult.h

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_EHPC_MODEL_LISTNODESNOPAGINGRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTNODESNOPAGINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListNodesNoPagingResult : public ServiceResult
+			{
+			public:
+				struct NodeInfo
+				{
+					struct TotalResources
+					{
+						int memory;
+						int cpu;
+						int gpu;
+					};
+					struct UsedResources
+					{
+						int memory;
+						int cpu;
+						int gpu;
+					};
+					std::string status;
+					std::string imageOwnerAlias;
+					bool expired;
+					std::string addTime;
+					std::vector<UsedResources> usedResources;
+					std::string role;
+					bool createdByEhpc;
+					std::vector<TotalResources> totalResources;
+					std::string expiredTime;
+					std::string imageId;
+					std::string id;
+					std::string regionId;
+					std::string lockReason;
+					std::string spotStrategy;
+				};
+
+
+				ListNodesNoPagingResult();
+				explicit ListNodesNoPagingResult(const std::string &payload);
+				~ListNodesNoPagingResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<NodeInfo> getNodes()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<NodeInfo> nodes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTNODESNOPAGINGRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListNodesRequest.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_EHPC_MODEL_LISTNODESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTNODESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListNodesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListNodesRequest();
+				~ListNodesRequest();
+
+				std::string getHostName()const;
+				void setHostName(const std::string& hostName);
+				std::string getRole()const;
+				void setRole(const std::string& role);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string hostName_;
+				std::string role_;
+				int pageSize_;
+				std::string clusterId_;
+				int pageNumber_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTNODESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListNodesResult.h

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_EHPC_MODEL_LISTNODESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTNODESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListNodesResult : public ServiceResult
+			{
+			public:
+				struct NodeInfo
+				{
+					struct TotalResources
+					{
+						int memory;
+						int cpu;
+						int gpu;
+					};
+					struct UsedResources
+					{
+						int memory;
+						int cpu;
+						int gpu;
+					};
+					std::string status;
+					std::string imageOwnerAlias;
+					bool expired;
+					std::string addTime;
+					std::vector<UsedResources> usedResources;
+					std::string role;
+					bool createdByEhpc;
+					std::vector<TotalResources> totalResources;
+					std::string expiredTime;
+					std::string imageId;
+					std::string id;
+					std::string regionId;
+					std::string lockReason;
+					std::string spotStrategy;
+				};
+
+
+				ListNodesResult();
+				explicit ListNodesResult(const std::string &payload);
+				~ListNodesResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<NodeInfo> getNodes()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<NodeInfo> nodes_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTNODESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListPreferredEcsTypesRequest.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_EHPC_MODEL_LISTPREFERREDECSTYPESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTPREFERREDECSTYPESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListPreferredEcsTypesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListPreferredEcsTypesRequest();
+				~ListPreferredEcsTypesRequest();
+
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string zoneId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTPREFERREDECSTYPESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListPreferredEcsTypesResult.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_EHPC_MODEL_LISTPREFERREDECSTYPESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTPREFERREDECSTYPESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListPreferredEcsTypesResult : public ServiceResult
+			{
+			public:
+				struct SeriesInfo
+				{
+					struct Roles
+					{
+						std::vector<std::string> compute;
+						std::vector<std::string> login;
+						std::vector<std::string> manager;
+					};
+					std::string seriesId;
+					std::string seriesName;
+					std::vector<Roles> roles;
+				};
+
+
+				ListPreferredEcsTypesResult();
+				explicit ListPreferredEcsTypesResult(const std::string &payload);
+				~ListPreferredEcsTypesResult();
+				std::vector<SeriesInfo> getSeries()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SeriesInfo> series_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTPREFERREDECSTYPESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListRegionsRequest.h

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

ehpc/include/alibabacloud/ehpc/model/ListRegionsResult.h

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_EHPC_MODEL_LISTREGIONSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTREGIONSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListRegionsResult : public ServiceResult
+			{
+			public:
+				struct RegionInfo
+				{
+					std::string regionId;
+					std::string localName;
+				};
+
+
+				ListRegionsResult();
+				explicit ListRegionsResult(const std::string &payload);
+				~ListRegionsResult();
+				std::vector<RegionInfo> getRegions()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<RegionInfo> regions_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTREGIONSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListSoftwaresRequest.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_EHPC_MODEL_LISTSOFTWARESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTSOFTWARESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListSoftwaresRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListSoftwaresRequest();
+				~ListSoftwaresRequest();
+
+				std::string getEhpcVersion()const;
+				void setEhpcVersion(const std::string& ehpcVersion);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string ehpcVersion_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTSOFTWARESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListSoftwaresResult.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_EHPC_MODEL_LISTSOFTWARESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTSOFTWARESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListSoftwaresResult : public ServiceResult
+			{
+			public:
+				struct SoftwareInfo
+				{
+					struct ApplicationInfo
+					{
+						bool required;
+						std::string version;
+						std::string tag;
+						std::string name;
+					};
+					std::vector<SoftwareInfo::ApplicationInfo> applications;
+					std::string schedulerVersion;
+					std::string osTag;
+					std::string schedulerType;
+					std::string accountType;
+					std::string accountVersion;
+					std::string ehpcVersion;
+				};
+
+
+				ListSoftwaresResult();
+				explicit ListSoftwaresResult(const std::string &payload);
+				~ListSoftwaresResult();
+				std::vector<SoftwareInfo> getSoftwares()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SoftwareInfo> softwares_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTSOFTWARESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListUsersRequest.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_EHPC_MODEL_LISTUSERSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTUSERSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListUsersRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListUsersRequest();
+				~ListUsersRequest();
+
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				int pageSize_;
+				std::string clusterId_;
+				int pageNumber_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTUSERSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListUsersResult.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_EHPC_MODEL_LISTUSERSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTUSERSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListUsersResult : public ServiceResult
+			{
+			public:
+				struct UserInfo
+				{
+					std::string group;
+					std::string addTime;
+					std::string name;
+				};
+
+
+				ListUsersResult();
+				explicit ListUsersResult(const std::string &payload);
+				~ListUsersResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<UserInfo> getUsers()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<UserInfo> users_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTUSERSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ListVolumesRequest.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_EHPC_MODEL_LISTVOLUMESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTVOLUMESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListVolumesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListVolumesRequest();
+				~ListVolumesRequest();
+
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				int pageSize_;
+				int pageNumber_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTVOLUMESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ListVolumesResult.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_EHPC_MODEL_LISTVOLUMESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_LISTVOLUMESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ListVolumesResult : public ServiceResult
+			{
+			public:
+				struct VolumeInfo
+				{
+					std::string volumeProtocol;
+					std::string volumeId;
+					std::string remoteDirectory;
+					std::string volumeType;
+					std::string clusterId;
+					std::string clusterName;
+					std::string regionId;
+					std::string volumeMountpoint;
+				};
+
+
+				ListVolumesResult();
+				explicit ListVolumesResult(const std::string &payload);
+				~ListVolumesResult();
+				int getTotalCount()const;
+				std::vector<VolumeInfo> getVolumes()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::vector<VolumeInfo> volumes_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_LISTVOLUMESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ModifyClusterAttributesRequest.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_EHPC_MODEL_MODIFYCLUSTERATTRIBUTESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_MODIFYCLUSTERATTRIBUTESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ModifyClusterAttributesRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyClusterAttributesRequest();
+				~ModifyClusterAttributesRequest();
+
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getDescription()const;
+				void setDescription(const std::string& description);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string name_;
+				std::string description_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_MODIFYCLUSTERATTRIBUTESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ModifyClusterAttributesResult.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_EHPC_MODEL_MODIFYCLUSTERATTRIBUTESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_MODIFYCLUSTERATTRIBUTESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ModifyClusterAttributesResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyClusterAttributesResult();
+				explicit ModifyClusterAttributesResult(const std::string &payload);
+				~ModifyClusterAttributesResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_MODIFYCLUSTERATTRIBUTESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ModifyUserGroupsRequest.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_MODIFYUSERGROUPSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_MODIFYUSERGROUPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ModifyUserGroupsRequest : public RpcServiceRequest
+			{
+				struct User
+				{
+					std::string name;
+					std::string group;
+				};
+
+			public:
+				ModifyUserGroupsRequest();
+				~ModifyUserGroupsRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::vector<User> getUser()const;
+				void setUser(const std::vector<User>& user);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string clusterId_;
+				std::vector<User> user_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_MODIFYUSERGROUPSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ModifyUserGroupsResult.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_EHPC_MODEL_MODIFYUSERGROUPSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_MODIFYUSERGROUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ModifyUserGroupsResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyUserGroupsResult();
+				explicit ModifyUserGroupsResult(const std::string &payload);
+				~ModifyUserGroupsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_MODIFYUSERGROUPSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ModifyUserPasswordsRequest.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_MODIFYUSERPASSWORDSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_MODIFYUSERPASSWORDSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ModifyUserPasswordsRequest : public RpcServiceRequest
+			{
+				struct User
+				{
+					std::string name;
+					std::string password;
+				};
+
+			public:
+				ModifyUserPasswordsRequest();
+				~ModifyUserPasswordsRequest();
+
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::vector<User> getUser()const;
+				void setUser(const std::vector<User>& user);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string clusterId_;
+				std::vector<User> user_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_MODIFYUSERPASSWORDSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ModifyUserPasswordsResult.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_EHPC_MODEL_MODIFYUSERPASSWORDSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_MODIFYUSERPASSWORDSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ModifyUserPasswordsResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyUserPasswordsResult();
+				explicit ModifyUserPasswordsResult(const std::string &payload);
+				~ModifyUserPasswordsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_MODIFYUSERPASSWORDSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/RerunJobsRequest.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_EHPC_MODEL_RERUNJOBSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_RERUNJOBSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT RerunJobsRequest : public RpcServiceRequest
+			{
+
+			public:
+				RerunJobsRequest();
+				~RerunJobsRequest();
+
+				std::string getJobs()const;
+				void setJobs(const std::string& jobs);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string jobs_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_RERUNJOBSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/RerunJobsResult.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_EHPC_MODEL_RERUNJOBSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_RERUNJOBSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT RerunJobsResult : public ServiceResult
+			{
+			public:
+
+
+				RerunJobsResult();
+				explicit RerunJobsResult(const std::string &payload);
+				~RerunJobsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_RERUNJOBSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/ResetNodesRequest.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_EHPC_MODEL_RESETNODESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_RESETNODESREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ResetNodesRequest : public RpcServiceRequest
+			{
+				struct Instance
+				{
+					std::string id;
+				};
+
+			public:
+				ResetNodesRequest();
+				~ResetNodesRequest();
+
+				std::vector<Instance> getInstance()const;
+				void setInstance(const std::vector<Instance>& instance);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::vector<Instance> instance_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_RESETNODESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ResetNodesResult.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_EHPC_MODEL_RESETNODESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_RESETNODESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT ResetNodesResult : public ServiceResult
+			{
+			public:
+
+
+				ResetNodesResult();
+				explicit ResetNodesResult(const std::string &payload);
+				~ResetNodesResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_RESETNODESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_SETAUTOSCALECONFIGREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_SETAUTOSCALECONFIGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT SetAutoScaleConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				SetAutoScaleConfigRequest();
+				~SetAutoScaleConfigRequest();
+
+				int getShrinkIdleTimes()const;
+				void setShrinkIdleTimes(int shrinkIdleTimes);
+				int getGrowTimeoutInMinutes()const;
+				void setGrowTimeoutInMinutes(int growTimeoutInMinutes);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				bool getEnableAutoGrow()const;
+				void setEnableAutoGrow(bool enableAutoGrow);
+				bool getEnableAutoShrink()const;
+				void setEnableAutoShrink(bool enableAutoShrink);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				int getMaxNodesInCluster()const;
+				void setMaxNodesInCluster(int maxNodesInCluster);
+				std::string getExcludeNodes()const;
+				void setExcludeNodes(const std::string& excludeNodes);
+				int getShrinkIntervalInMinutes()const;
+				void setShrinkIntervalInMinutes(int shrinkIntervalInMinutes);
+				int getExtraNodesGrowRatio()const;
+				void setExtraNodesGrowRatio(int extraNodesGrowRatio);
+				int getGrowIntervalInMinutes()const;
+				void setGrowIntervalInMinutes(int growIntervalInMinutes);
+				int getGrowRatio()const;
+				void setGrowRatio(int growRatio);
+
+            private:
+				int shrinkIdleTimes_;
+				int growTimeoutInMinutes_;
+				std::string clusterId_;
+				bool enableAutoGrow_;
+				bool enableAutoShrink_;
+				std::string accessKeyId_;
+				int maxNodesInCluster_;
+				std::string excludeNodes_;
+				int shrinkIntervalInMinutes_;
+				int extraNodesGrowRatio_;
+				int growIntervalInMinutes_;
+				int growRatio_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_SETAUTOSCALECONFIGREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/SetAutoScaleConfigResult.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_EHPC_MODEL_SETAUTOSCALECONFIGRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_SETAUTOSCALECONFIGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT SetAutoScaleConfigResult : public ServiceResult
+			{
+			public:
+
+
+				SetAutoScaleConfigResult();
+				explicit SetAutoScaleConfigResult(const std::string &payload);
+				~SetAutoScaleConfigResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_SETAUTOSCALECONFIGRESULT_H_

ehpc/include/alibabacloud/ehpc/model/SetJobUserRequest.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_EHPC_MODEL_SETJOBUSERREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_SETJOBUSERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT SetJobUserRequest : public RpcServiceRequest
+			{
+
+			public:
+				SetJobUserRequest();
+				~SetJobUserRequest();
+
+				std::string getRunasUserPassword()const;
+				void setRunasUserPassword(const std::string& runasUserPassword);
+				std::string getRunasUser()const;
+				void setRunasUser(const std::string& runasUser);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string runasUserPassword_;
+				std::string runasUser_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_SETJOBUSERREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/SetJobUserResult.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_EHPC_MODEL_SETJOBUSERRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_SETJOBUSERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT SetJobUserResult : public ServiceResult
+			{
+			public:
+
+
+				SetJobUserResult();
+				explicit SetJobUserResult(const std::string &payload);
+				~SetJobUserResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_SETJOBUSERRESULT_H_

ehpc/include/alibabacloud/ehpc/model/StopJobsRequest.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_EHPC_MODEL_STOPJOBSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_STOPJOBSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT StopJobsRequest : public RpcServiceRequest
+			{
+
+			public:
+				StopJobsRequest();
+				~StopJobsRequest();
+
+				std::string getJobs()const;
+				void setJobs(const std::string& jobs);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string jobs_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_STOPJOBSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/StopJobsResult.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_EHPC_MODEL_STOPJOBSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_STOPJOBSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT StopJobsResult : public ServiceResult
+			{
+			public:
+
+
+				StopJobsResult();
+				explicit StopJobsResult(const std::string &payload);
+				~StopJobsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_STOPJOBSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/SubmitJobRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_SUBMITJOBREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_SUBMITJOBREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT SubmitJobRequest : public RpcServiceRequest
+			{
+
+			public:
+				SubmitJobRequest();
+				~SubmitJobRequest();
+
+				std::string getStderrRedirectPath()const;
+				void setStderrRedirectPath(const std::string& stderrRedirectPath);
+				std::string getVariables()const;
+				void setVariables(const std::string& variables);
+				std::string getRunasUserPassword()const;
+				void setRunasUserPassword(const std::string& runasUserPassword);
+				std::string getRunasUser()const;
+				void setRunasUser(const std::string& runasUser);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				bool getReRunable()const;
+				void setReRunable(bool reRunable);
+				int getPriority()const;
+				void setPriority(int priority);
+				std::string getCommandLine()const;
+				void setCommandLine(const std::string& commandLine);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getArrayRequest()const;
+				void setArrayRequest(const std::string& arrayRequest);
+				std::string getPackagePath()const;
+				void setPackagePath(const std::string& packagePath);
+				std::string getName()const;
+				void setName(const std::string& name);
+				std::string getStdoutRedirectPath()const;
+				void setStdoutRedirectPath(const std::string& stdoutRedirectPath);
+
+            private:
+				std::string stderrRedirectPath_;
+				std::string variables_;
+				std::string runasUserPassword_;
+				std::string runasUser_;
+				std::string clusterId_;
+				bool reRunable_;
+				int priority_;
+				std::string commandLine_;
+				std::string accessKeyId_;
+				std::string arrayRequest_;
+				std::string packagePath_;
+				std::string name_;
+				std::string stdoutRedirectPath_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_SUBMITJOBREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/SubmitJobResult.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_EHPC_MODEL_SUBMITJOBRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_SUBMITJOBRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT SubmitJobResult : public ServiceResult
+			{
+			public:
+
+
+				SubmitJobResult();
+				explicit SubmitJobResult(const std::string &payload);
+				~SubmitJobResult();
+				std::string getJobId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string jobId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_SUBMITJOBRESULT_H_

ehpc/include/alibabacloud/ehpc/model/UpgradeClientRequest.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_EHPC_MODEL_UPGRADECLIENTREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_UPGRADECLIENTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT UpgradeClientRequest : public RpcServiceRequest
+			{
+
+			public:
+				UpgradeClientRequest();
+				~UpgradeClientRequest();
+
+				std::string getClientVersion()const;
+				void setClientVersion(const std::string& clientVersion);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string clientVersion_;
+				std::string clusterId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_UPGRADECLIENTREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/UpgradeClientResult.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_EHPC_MODEL_UPGRADECLIENTRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_UPGRADECLIENTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ehpc/EHPCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace EHPC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_EHPC_EXPORT UpgradeClientResult : public ServiceResult
+			{
+			public:
+
+
+				UpgradeClientResult();
+				explicit UpgradeClientResult(const std::string &payload);
+				~UpgradeClientResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_UPGRADECLIENTRESULT_H_

ehpc/src/EHPCClient.cc

@@ -0,0 +1,1357 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ehpc/EHPCClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+EHPCClient::EHPCClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), "ehs");
+}
+
+EHPCClient::EHPCClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), "ehs");
+}
+
+EHPCClient::EHPCClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), "ehs");
+}
+
+EHPCClient::~EHPCClient()
+{}
+
+CoreClient::EndpointOutcome EHPCClient::endpoint()const
+{
+	if(!configuration().endpoint().empty())
+		return CoreClient::EndpointOutcome(configuration().endpoint());
+
+	auto endpoint = endpointProvider_->getEndpoint();
+	
+	if (endpoint.empty())
+		return CoreClient::EndpointOutcome(Error("InvalidEndpoint",""));
+	else
+		return CoreClient::EndpointOutcome(endpoint);
+}
+
+EHPCClient::DeleteUsersOutcome EHPCClient::deleteUsers(const DeleteUsersRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteUsersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteUsersOutcome(DeleteUsersResult(outcome.result()));
+	else
+		return DeleteUsersOutcome(outcome.error());
+}
+
+void EHPCClient::deleteUsersAsync(const DeleteUsersRequest& request, const DeleteUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteUsers(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::DeleteUsersOutcomeCallable EHPCClient::deleteUsersCallable(const DeleteUsersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteUsersOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteUsers(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::DescribeClusterOutcome EHPCClient::describeCluster(const DescribeClusterRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeClusterOutcome(DescribeClusterResult(outcome.result()));
+	else
+		return DescribeClusterOutcome(outcome.error());
+}
+
+void EHPCClient::describeClusterAsync(const DescribeClusterRequest& request, const DescribeClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::DescribeClusterOutcomeCallable EHPCClient::describeClusterCallable(const DescribeClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListUsersOutcome EHPCClient::listUsers(const ListUsersRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListUsersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListUsersOutcome(ListUsersResult(outcome.result()));
+	else
+		return ListUsersOutcome(outcome.error());
+}
+
+void EHPCClient::listUsersAsync(const ListUsersRequest& request, const ListUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listUsers(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListUsersOutcomeCallable EHPCClient::listUsersCallable(const ListUsersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListUsersOutcome()>>(
+			[this, request]()
+			{
+			return this->listUsers(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::UpgradeClientOutcome EHPCClient::upgradeClient(const UpgradeClientRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpgradeClientOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpgradeClientOutcome(UpgradeClientResult(outcome.result()));
+	else
+		return UpgradeClientOutcome(outcome.error());
+}
+
+void EHPCClient::upgradeClientAsync(const UpgradeClientRequest& request, const UpgradeClientAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, upgradeClient(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::UpgradeClientOutcomeCallable EHPCClient::upgradeClientCallable(const UpgradeClientRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpgradeClientOutcome()>>(
+			[this, request]()
+			{
+			return this->upgradeClient(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListCurrentClientVersionOutcome EHPCClient::listCurrentClientVersion(const ListCurrentClientVersionRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListCurrentClientVersionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListCurrentClientVersionOutcome(ListCurrentClientVersionResult(outcome.result()));
+	else
+		return ListCurrentClientVersionOutcome(outcome.error());
+}
+
+void EHPCClient::listCurrentClientVersionAsync(const ListCurrentClientVersionRequest& request, const ListCurrentClientVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listCurrentClientVersion(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListCurrentClientVersionOutcomeCallable EHPCClient::listCurrentClientVersionCallable(const ListCurrentClientVersionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListCurrentClientVersionOutcome()>>(
+			[this, request]()
+			{
+			return this->listCurrentClientVersion(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::DeleteClusterOutcome EHPCClient::deleteCluster(const DeleteClusterRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteClusterOutcome(DeleteClusterResult(outcome.result()));
+	else
+		return DeleteClusterOutcome(outcome.error());
+}
+
+void EHPCClient::deleteClusterAsync(const DeleteClusterRequest& request, const DeleteClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::DeleteClusterOutcomeCallable EHPCClient::deleteClusterCallable(const DeleteClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListImagesOutcome EHPCClient::listImages(const ListImagesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListImagesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListImagesOutcome(ListImagesResult(outcome.result()));
+	else
+		return ListImagesOutcome(outcome.error());
+}
+
+void EHPCClient::listImagesAsync(const ListImagesRequest& request, const ListImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listImages(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListImagesOutcomeCallable EHPCClient::listImagesCallable(const ListImagesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListImagesOutcome()>>(
+			[this, request]()
+			{
+			return this->listImages(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::SetAutoScaleConfigOutcome EHPCClient::setAutoScaleConfig(const SetAutoScaleConfigRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetAutoScaleConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetAutoScaleConfigOutcome(SetAutoScaleConfigResult(outcome.result()));
+	else
+		return SetAutoScaleConfigOutcome(outcome.error());
+}
+
+void EHPCClient::setAutoScaleConfigAsync(const SetAutoScaleConfigRequest& request, const SetAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setAutoScaleConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::SetAutoScaleConfigOutcomeCallable EHPCClient::setAutoScaleConfigCallable(const SetAutoScaleConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetAutoScaleConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->setAutoScaleConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListVolumesOutcome EHPCClient::listVolumes(const ListVolumesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListVolumesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListVolumesOutcome(ListVolumesResult(outcome.result()));
+	else
+		return ListVolumesOutcome(outcome.error());
+}
+
+void EHPCClient::listVolumesAsync(const ListVolumesRequest& request, const ListVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listVolumes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListVolumesOutcomeCallable EHPCClient::listVolumesCallable(const ListVolumesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListVolumesOutcome()>>(
+			[this, request]()
+			{
+			return this->listVolumes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::AddNodesOutcome EHPCClient::addNodes(const AddNodesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddNodesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddNodesOutcome(AddNodesResult(outcome.result()));
+	else
+		return AddNodesOutcome(outcome.error());
+}
+
+void EHPCClient::addNodesAsync(const AddNodesRequest& request, const AddNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addNodes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::AddNodesOutcomeCallable EHPCClient::addNodesCallable(const AddNodesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddNodesOutcome()>>(
+			[this, request]()
+			{
+			return this->addNodes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListSoftwaresOutcome EHPCClient::listSoftwares(const ListSoftwaresRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListSoftwaresOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListSoftwaresOutcome(ListSoftwaresResult(outcome.result()));
+	else
+		return ListSoftwaresOutcome(outcome.error());
+}
+
+void EHPCClient::listSoftwaresAsync(const ListSoftwaresRequest& request, const ListSoftwaresAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listSoftwares(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListSoftwaresOutcomeCallable EHPCClient::listSoftwaresCallable(const ListSoftwaresRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListSoftwaresOutcome()>>(
+			[this, request]()
+			{
+			return this->listSoftwares(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::StopJobsOutcome EHPCClient::stopJobs(const StopJobsRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopJobsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopJobsOutcome(StopJobsResult(outcome.result()));
+	else
+		return StopJobsOutcome(outcome.error());
+}
+
+void EHPCClient::stopJobsAsync(const StopJobsRequest& request, const StopJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopJobs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::StopJobsOutcomeCallable EHPCClient::stopJobsCallable(const StopJobsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopJobsOutcome()>>(
+			[this, request]()
+			{
+			return this->stopJobs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::GetAutoScaleConfigOutcome EHPCClient::getAutoScaleConfig(const GetAutoScaleConfigRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAutoScaleConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAutoScaleConfigOutcome(GetAutoScaleConfigResult(outcome.result()));
+	else
+		return GetAutoScaleConfigOutcome(outcome.error());
+}
+
+void EHPCClient::getAutoScaleConfigAsync(const GetAutoScaleConfigRequest& request, const GetAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAutoScaleConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::GetAutoScaleConfigOutcomeCallable EHPCClient::getAutoScaleConfigCallable(const GetAutoScaleConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAutoScaleConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->getAutoScaleConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListNodesOutcome EHPCClient::listNodes(const ListNodesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListNodesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListNodesOutcome(ListNodesResult(outcome.result()));
+	else
+		return ListNodesOutcome(outcome.error());
+}
+
+void EHPCClient::listNodesAsync(const ListNodesRequest& request, const ListNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listNodes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListNodesOutcomeCallable EHPCClient::listNodesCallable(const ListNodesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListNodesOutcome()>>(
+			[this, request]()
+			{
+			return this->listNodes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::SetJobUserOutcome EHPCClient::setJobUser(const SetJobUserRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetJobUserOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetJobUserOutcome(SetJobUserResult(outcome.result()));
+	else
+		return SetJobUserOutcome(outcome.error());
+}
+
+void EHPCClient::setJobUserAsync(const SetJobUserRequest& request, const SetJobUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setJobUser(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::SetJobUserOutcomeCallable EHPCClient::setJobUserCallable(const SetJobUserRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetJobUserOutcome()>>(
+			[this, request]()
+			{
+			return this->setJobUser(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ModifyUserGroupsOutcome EHPCClient::modifyUserGroups(const ModifyUserGroupsRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyUserGroupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyUserGroupsOutcome(ModifyUserGroupsResult(outcome.result()));
+	else
+		return ModifyUserGroupsOutcome(outcome.error());
+}
+
+void EHPCClient::modifyUserGroupsAsync(const ModifyUserGroupsRequest& request, const ModifyUserGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyUserGroups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ModifyUserGroupsOutcomeCallable EHPCClient::modifyUserGroupsCallable(const ModifyUserGroupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyUserGroupsOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyUserGroups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListClustersOutcome EHPCClient::listClusters(const ListClustersRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListClustersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListClustersOutcome(ListClustersResult(outcome.result()));
+	else
+		return ListClustersOutcome(outcome.error());
+}
+
+void EHPCClient::listClustersAsync(const ListClustersRequest& request, const ListClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listClusters(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListClustersOutcomeCallable EHPCClient::listClustersCallable(const ListClustersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListClustersOutcome()>>(
+			[this, request]()
+			{
+			return this->listClusters(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::SubmitJobOutcome EHPCClient::submitJob(const SubmitJobRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return SubmitJobOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SubmitJobOutcome(SubmitJobResult(outcome.result()));
+	else
+		return SubmitJobOutcome(outcome.error());
+}
+
+void EHPCClient::submitJobAsync(const SubmitJobRequest& request, const SubmitJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, submitJob(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::SubmitJobOutcomeCallable EHPCClient::submitJobCallable(const SubmitJobRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SubmitJobOutcome()>>(
+			[this, request]()
+			{
+			return this->submitJob(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListCustomImagesOutcome EHPCClient::listCustomImages(const ListCustomImagesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListCustomImagesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListCustomImagesOutcome(ListCustomImagesResult(outcome.result()));
+	else
+		return ListCustomImagesOutcome(outcome.error());
+}
+
+void EHPCClient::listCustomImagesAsync(const ListCustomImagesRequest& request, const ListCustomImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listCustomImages(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListCustomImagesOutcomeCallable EHPCClient::listCustomImagesCallable(const ListCustomImagesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListCustomImagesOutcome()>>(
+			[this, request]()
+			{
+			return this->listCustomImages(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListRegionsOutcome EHPCClient::listRegions(const ListRegionsRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListRegionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListRegionsOutcome(ListRegionsResult(outcome.result()));
+	else
+		return ListRegionsOutcome(outcome.error());
+}
+
+void EHPCClient::listRegionsAsync(const ListRegionsRequest& request, const ListRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listRegions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListRegionsOutcomeCallable EHPCClient::listRegionsCallable(const ListRegionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListRegionsOutcome()>>(
+			[this, request]()
+			{
+			return this->listRegions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::AddUsersOutcome EHPCClient::addUsers(const AddUsersRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddUsersOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddUsersOutcome(AddUsersResult(outcome.result()));
+	else
+		return AddUsersOutcome(outcome.error());
+}
+
+void EHPCClient::addUsersAsync(const AddUsersRequest& request, const AddUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addUsers(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::AddUsersOutcomeCallable EHPCClient::addUsersCallable(const AddUsersRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddUsersOutcome()>>(
+			[this, request]()
+			{
+			return this->addUsers(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListJobTemplatesOutcome EHPCClient::listJobTemplates(const ListJobTemplatesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListJobTemplatesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListJobTemplatesOutcome(ListJobTemplatesResult(outcome.result()));
+	else
+		return ListJobTemplatesOutcome(outcome.error());
+}
+
+void EHPCClient::listJobTemplatesAsync(const ListJobTemplatesRequest& request, const ListJobTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listJobTemplates(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListJobTemplatesOutcomeCallable EHPCClient::listJobTemplatesCallable(const ListJobTemplatesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListJobTemplatesOutcome()>>(
+			[this, request]()
+			{
+			return this->listJobTemplates(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ModifyClusterAttributesOutcome EHPCClient::modifyClusterAttributes(const ModifyClusterAttributesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyClusterAttributesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyClusterAttributesOutcome(ModifyClusterAttributesResult(outcome.result()));
+	else
+		return ModifyClusterAttributesOutcome(outcome.error());
+}
+
+void EHPCClient::modifyClusterAttributesAsync(const ModifyClusterAttributesRequest& request, const ModifyClusterAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyClusterAttributes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ModifyClusterAttributesOutcomeCallable EHPCClient::modifyClusterAttributesCallable(const ModifyClusterAttributesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyClusterAttributesOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyClusterAttributes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::DeleteJobTemplatesOutcome EHPCClient::deleteJobTemplates(const DeleteJobTemplatesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteJobTemplatesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteJobTemplatesOutcome(DeleteJobTemplatesResult(outcome.result()));
+	else
+		return DeleteJobTemplatesOutcome(outcome.error());
+}
+
+void EHPCClient::deleteJobTemplatesAsync(const DeleteJobTemplatesRequest& request, const DeleteJobTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteJobTemplates(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::DeleteJobTemplatesOutcomeCallable EHPCClient::deleteJobTemplatesCallable(const DeleteJobTemplatesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteJobTemplatesOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteJobTemplates(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListNodesNoPagingOutcome EHPCClient::listNodesNoPaging(const ListNodesNoPagingRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListNodesNoPagingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListNodesNoPagingOutcome(ListNodesNoPagingResult(outcome.result()));
+	else
+		return ListNodesNoPagingOutcome(outcome.error());
+}
+
+void EHPCClient::listNodesNoPagingAsync(const ListNodesNoPagingRequest& request, const ListNodesNoPagingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listNodesNoPaging(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListNodesNoPagingOutcomeCallable EHPCClient::listNodesNoPagingCallable(const ListNodesNoPagingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListNodesNoPagingOutcome()>>(
+			[this, request]()
+			{
+			return this->listNodesNoPaging(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::CreateJobTemplateOutcome EHPCClient::createJobTemplate(const CreateJobTemplateRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateJobTemplateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateJobTemplateOutcome(CreateJobTemplateResult(outcome.result()));
+	else
+		return CreateJobTemplateOutcome(outcome.error());
+}
+
+void EHPCClient::createJobTemplateAsync(const CreateJobTemplateRequest& request, const CreateJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createJobTemplate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::CreateJobTemplateOutcomeCallable EHPCClient::createJobTemplateCallable(const CreateJobTemplateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateJobTemplateOutcome()>>(
+			[this, request]()
+			{
+			return this->createJobTemplate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::RerunJobsOutcome EHPCClient::rerunJobs(const RerunJobsRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return RerunJobsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RerunJobsOutcome(RerunJobsResult(outcome.result()));
+	else
+		return RerunJobsOutcome(outcome.error());
+}
+
+void EHPCClient::rerunJobsAsync(const RerunJobsRequest& request, const RerunJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, rerunJobs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::RerunJobsOutcomeCallable EHPCClient::rerunJobsCallable(const RerunJobsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RerunJobsOutcome()>>(
+			[this, request]()
+			{
+			return this->rerunJobs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ResetNodesOutcome EHPCClient::resetNodes(const ResetNodesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ResetNodesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ResetNodesOutcome(ResetNodesResult(outcome.result()));
+	else
+		return ResetNodesOutcome(outcome.error());
+}
+
+void EHPCClient::resetNodesAsync(const ResetNodesRequest& request, const ResetNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, resetNodes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ResetNodesOutcomeCallable EHPCClient::resetNodesCallable(const ResetNodesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ResetNodesOutcome()>>(
+			[this, request]()
+			{
+			return this->resetNodes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::EditJobTemplateOutcome EHPCClient::editJobTemplate(const EditJobTemplateRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return EditJobTemplateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return EditJobTemplateOutcome(EditJobTemplateResult(outcome.result()));
+	else
+		return EditJobTemplateOutcome(outcome.error());
+}
+
+void EHPCClient::editJobTemplateAsync(const EditJobTemplateRequest& request, const EditJobTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, editJobTemplate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::EditJobTemplateOutcomeCallable EHPCClient::editJobTemplateCallable(const EditJobTemplateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<EditJobTemplateOutcome()>>(
+			[this, request]()
+			{
+			return this->editJobTemplate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListPreferredEcsTypesOutcome EHPCClient::listPreferredEcsTypes(const ListPreferredEcsTypesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListPreferredEcsTypesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListPreferredEcsTypesOutcome(ListPreferredEcsTypesResult(outcome.result()));
+	else
+		return ListPreferredEcsTypesOutcome(outcome.error());
+}
+
+void EHPCClient::listPreferredEcsTypesAsync(const ListPreferredEcsTypesRequest& request, const ListPreferredEcsTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listPreferredEcsTypes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListPreferredEcsTypesOutcomeCallable EHPCClient::listPreferredEcsTypesCallable(const ListPreferredEcsTypesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListPreferredEcsTypesOutcome()>>(
+			[this, request]()
+			{
+			return this->listPreferredEcsTypes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListClusterLogsOutcome EHPCClient::listClusterLogs(const ListClusterLogsRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListClusterLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListClusterLogsOutcome(ListClusterLogsResult(outcome.result()));
+	else
+		return ListClusterLogsOutcome(outcome.error());
+}
+
+void EHPCClient::listClusterLogsAsync(const ListClusterLogsRequest& request, const ListClusterLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listClusterLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListClusterLogsOutcomeCallable EHPCClient::listClusterLogsCallable(const ListClusterLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListClusterLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->listClusterLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::DeleteJobsOutcome EHPCClient::deleteJobs(const DeleteJobsRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteJobsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteJobsOutcome(DeleteJobsResult(outcome.result()));
+	else
+		return DeleteJobsOutcome(outcome.error());
+}
+
+void EHPCClient::deleteJobsAsync(const DeleteJobsRequest& request, const DeleteJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteJobs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::DeleteJobsOutcomeCallable EHPCClient::deleteJobsCallable(const DeleteJobsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteJobsOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteJobs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::DeleteNodesOutcome EHPCClient::deleteNodes(const DeleteNodesRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteNodesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteNodesOutcome(DeleteNodesResult(outcome.result()));
+	else
+		return DeleteNodesOutcome(outcome.error());
+}
+
+void EHPCClient::deleteNodesAsync(const DeleteNodesRequest& request, const DeleteNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteNodes(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::DeleteNodesOutcomeCallable EHPCClient::deleteNodesCallable(const DeleteNodesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteNodesOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteNodes(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ListJobsOutcome EHPCClient::listJobs(const ListJobsRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListJobsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListJobsOutcome(ListJobsResult(outcome.result()));
+	else
+		return ListJobsOutcome(outcome.error());
+}
+
+void EHPCClient::listJobsAsync(const ListJobsRequest& request, const ListJobsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listJobs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ListJobsOutcomeCallable EHPCClient::listJobsCallable(const ListJobsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListJobsOutcome()>>(
+			[this, request]()
+			{
+			return this->listJobs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::CreateClusterOutcome EHPCClient::createCluster(const CreateClusterRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateClusterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateClusterOutcome(CreateClusterResult(outcome.result()));
+	else
+		return CreateClusterOutcome(outcome.error());
+}
+
+void EHPCClient::createClusterAsync(const CreateClusterRequest& request, const CreateClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createCluster(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::CreateClusterOutcomeCallable EHPCClient::createClusterCallable(const CreateClusterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateClusterOutcome()>>(
+			[this, request]()
+			{
+			return this->createCluster(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+EHPCClient::ModifyUserPasswordsOutcome EHPCClient::modifyUserPasswords(const ModifyUserPasswordsRequest &request) const
+{
+	auto endpointOutcome = endpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyUserPasswordsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyUserPasswordsOutcome(ModifyUserPasswordsResult(outcome.result()));
+	else
+		return ModifyUserPasswordsOutcome(outcome.error());
+}
+
+void EHPCClient::modifyUserPasswordsAsync(const ModifyUserPasswordsRequest& request, const ModifyUserPasswordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyUserPasswords(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+EHPCClient::ModifyUserPasswordsOutcomeCallable EHPCClient::modifyUserPasswordsCallable(const ModifyUserPasswordsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyUserPasswordsOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyUserPasswords(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

ehpc/src/model/AddNodesRequest.cc

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ehpc/model/AddNodesRequest.h>
+
+using AlibabaCloud::EHPC::Model::AddNodesRequest;
+
+AddNodesRequest::AddNodesRequest() :
+	RpcServiceRequest("ehpc", "2017-07-14", "AddNodes")
+{}
+
+AddNodesRequest::~AddNodesRequest()
+{}
+
+std::string AddNodesRequest::getImageId()const
+{
+	return imageId_;
+}
+
+void AddNodesRequest::setImageId(const std::string& imageId)
+{
+	imageId_ = imageId;
+	setParameter("ImageId", imageId);
+}
+
+int AddNodesRequest::getCount()const
+{
+	return count_;
+}
+
+void AddNodesRequest::setCount(int count)
+{
+	count_ = count;
+	setParameter("Count", std::to_string(count));
+}
+
+std::string AddNodesRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void AddNodesRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string AddNodesRequest::getComputeSpotStrategy()const
+{
+	return computeSpotStrategy_;
+}
+
+void AddNodesRequest::setComputeSpotStrategy(const std::string& computeSpotStrategy)
+{
+	computeSpotStrategy_ = computeSpotStrategy;
+	setParameter("ComputeSpotStrategy", computeSpotStrategy);
+}
+
+std::string AddNodesRequest::getComputeSpotPriceLimit()const
+{
+	return computeSpotPriceLimit_;
+}
+
+void AddNodesRequest::setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit)
+{
+	computeSpotPriceLimit_ = computeSpotPriceLimit;
+	setParameter("ComputeSpotPriceLimit", computeSpotPriceLimit);
+}
+
+std::string AddNodesRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void AddNodesRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string AddNodesRequest::getImageOwnerAlias()const
+{
+	return imageOwnerAlias_;
+}
+
+void AddNodesRequest::setImageOwnerAlias(const std::string& imageOwnerAlias)
+{
+	imageOwnerAlias_ = imageOwnerAlias;
+	setParameter("ImageOwnerAlias", imageOwnerAlias);
+}
+

ehpc/src/model/AddNodesResult.cc

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

ehpc/src/model/AddUsersRequest.cc

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/AddUsersRequest.h>
+
+using AlibabaCloud::EHPC::Model::AddUsersRequest;
+
+AddUsersRequest::AddUsersRequest() :
+	RpcServiceRequest("ehpc", "2017-07-14", "AddUsers")
+{}
+
+AddUsersRequest::~AddUsersRequest()
+{}
+
+bool AddUsersRequest::getReleaseInstance()const
+{
+	return releaseInstance_;
+}
+
+void AddUsersRequest::setReleaseInstance(bool releaseInstance)
+{
+	releaseInstance_ = releaseInstance;
+	setParameter("ReleaseInstance", std::to_string(releaseInstance));
+}
+
+std::string AddUsersRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void AddUsersRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::vector<AddUsersRequest::User> AddUsersRequest::getUser()const
+{
+	return user_;
+}
+
+void AddUsersRequest::setUser(const std::vector<User>& user)
+{
+	user_ = user;
+	int i = 0;
+	for(int i = 0; i!= user.size(); i++)	{
+		auto obj = user.at(i);
+		std::string str ="User."+ std::to_string(i);
+		setParameter(str + ".Name", obj.name);
+		setParameter(str + ".Group", obj.group);
+		setParameter(str + ".Password", obj.password);
+	}
+}
+
+std::string AddUsersRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void AddUsersRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

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

ehpc/src/model/CreateClusterRequest.cc

@@ -0,0 +1,384 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ehpc/model/CreateClusterRequest.h>
+
+using AlibabaCloud::EHPC::Model::CreateClusterRequest;
+
+CreateClusterRequest::CreateClusterRequest() :
+	RpcServiceRequest("ehpc", "2017-07-14", "CreateCluster")
+{}
+
+CreateClusterRequest::~CreateClusterRequest()
+{}
+
+std::string CreateClusterRequest::getSccClusterId()const
+{
+	return sccClusterId_;
+}
+
+void CreateClusterRequest::setSccClusterId(const std::string& sccClusterId)
+{
+	sccClusterId_ = sccClusterId;
+	setParameter("SccClusterId", sccClusterId);
+}
+
+std::string CreateClusterRequest::getImageId()const
+{
+	return imageId_;
+}
+
+void CreateClusterRequest::setImageId(const std::string& imageId)
+{
+	imageId_ = imageId;
+	setParameter("ImageId", imageId);
+}
+
+std::string CreateClusterRequest::getEcsOrderManagerInstanceType()const
+{
+	return ecsOrderManagerInstanceType_;
+}
+
+void CreateClusterRequest::setEcsOrderManagerInstanceType(const std::string& ecsOrderManagerInstanceType)
+{
+	ecsOrderManagerInstanceType_ = ecsOrderManagerInstanceType;
+	setParameter("EcsOrderManagerInstanceType", ecsOrderManagerInstanceType);
+}
+
+std::string CreateClusterRequest::getEhpcVersion()const
+{
+	return ehpcVersion_;
+}
+
+void CreateClusterRequest::setEhpcVersion(const std::string& ehpcVersion)
+{
+	ehpcVersion_ = ehpcVersion;
+	setParameter("EhpcVersion", ehpcVersion);
+}
+
+std::string CreateClusterRequest::getAccountType()const
+{
+	return accountType_;
+}
+
+void CreateClusterRequest::setAccountType(const std::string& accountType)
+{
+	accountType_ = accountType;
+	setParameter("AccountType", accountType);
+}
+
+std::string CreateClusterRequest::getSecurityGroupId()const
+{
+	return securityGroupId_;
+}
+
+void CreateClusterRequest::setSecurityGroupId(const std::string& securityGroupId)
+{
+	securityGroupId_ = securityGroupId;
+	setParameter("SecurityGroupId", securityGroupId);
+}
+
+std::string CreateClusterRequest::getDescription()const
+{
+	return description_;
+}
+
+void CreateClusterRequest::setDescription(const std::string& description)
+{
+	description_ = description;
+	setParameter("Description", description);
+}
+
+std::string CreateClusterRequest::getKeyPairName()const
+{
+	return keyPairName_;
+}
+
+void CreateClusterRequest::setKeyPairName(const std::string& keyPairName)
+{
+	keyPairName_ = keyPairName;
+	setParameter("KeyPairName", keyPairName);
+}
+
+std::string CreateClusterRequest::getSecurityGroupName()const
+{
+	return securityGroupName_;
+}
+
+void CreateClusterRequest::setSecurityGroupName(const std::string& securityGroupName)
+{
+	securityGroupName_ = securityGroupName;
+	setParameter("SecurityGroupName", securityGroupName);
+}
+
+std::string CreateClusterRequest::getEcsOrderComputeInstanceType()const
+{
+	return ecsOrderComputeInstanceType_;
+}
+
+void CreateClusterRequest::setEcsOrderComputeInstanceType(const std::string& ecsOrderComputeInstanceType)
+{
+	ecsOrderComputeInstanceType_ = ecsOrderComputeInstanceType;
+	setParameter("EcsOrderComputeInstanceType", ecsOrderComputeInstanceType);
+}
+
+std::string CreateClusterRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateClusterRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateClusterRequest::getImageOwnerAlias()const
+{
+	return imageOwnerAlias_;
+}
+
+void CreateClusterRequest::setImageOwnerAlias(const std::string& imageOwnerAlias)
+{
+	imageOwnerAlias_ = imageOwnerAlias;
+	setParameter("ImageOwnerAlias", imageOwnerAlias);
+}
+
+std::string CreateClusterRequest::getVolumeType()const
+{
+	return volumeType_;
+}
+
+void CreateClusterRequest::setVolumeType(const std::string& volumeType)
+{
+	volumeType_ = volumeType;
+	setParameter("VolumeType", volumeType);
+}
+
+int CreateClusterRequest::getEcsOrderManagerCount()const
+{
+	return ecsOrderManagerCount_;
+}
+
+void CreateClusterRequest::setEcsOrderManagerCount(int ecsOrderManagerCount)
+{
+	ecsOrderManagerCount_ = ecsOrderManagerCount;
+	setParameter("EcsOrderManagerCount", std::to_string(ecsOrderManagerCount));
+}
+
+std::string CreateClusterRequest::getPassword()const
+{
+	return password_;
+}
+
+void CreateClusterRequest::setPassword(const std::string& password)
+{
+	password_ = password;
+	setParameter("Password", password);
+}
+
+int CreateClusterRequest::getEcsOrderLoginCount()const
+{
+	return ecsOrderLoginCount_;
+}
+
+void CreateClusterRequest::setEcsOrderLoginCount(int ecsOrderLoginCount)
+{
+	ecsOrderLoginCount_ = ecsOrderLoginCount;
+	setParameter("EcsOrderLoginCount", std::to_string(ecsOrderLoginCount));
+}
+
+std::string CreateClusterRequest::getComputeSpotPriceLimit()const
+{
+	return computeSpotPriceLimit_;
+}
+
+void CreateClusterRequest::setComputeSpotPriceLimit(const std::string& computeSpotPriceLimit)
+{
+	computeSpotPriceLimit_ = computeSpotPriceLimit;
+	setParameter("ComputeSpotPriceLimit", computeSpotPriceLimit);
+}
+
+std::string CreateClusterRequest::getVolumeProtocol()const
+{
+	return volumeProtocol_;
+}
+
+void CreateClusterRequest::setVolumeProtocol(const std::string& volumeProtocol)
+{
+	volumeProtocol_ = volumeProtocol;
+	setParameter("VolumeProtocol", volumeProtocol);
+}
+
+std::string CreateClusterRequest::getOsTag()const
+{
+	return osTag_;
+}
+
+void CreateClusterRequest::setOsTag(const std::string& osTag)
+{
+	osTag_ = osTag;
+	setParameter("OsTag", osTag);
+}
+
+std::string CreateClusterRequest::getRemoteDirectory()const
+{
+	return remoteDirectory_;
+}
+
+void CreateClusterRequest::setRemoteDirectory(const std::string& remoteDirectory)
+{
+	remoteDirectory_ = remoteDirectory;
+	setParameter("RemoteDirectory", remoteDirectory);
+}
+
+int CreateClusterRequest::getEcsOrderComputeCount()const
+{
+	return ecsOrderComputeCount_;
+}
+
+void CreateClusterRequest::setEcsOrderComputeCount(int ecsOrderComputeCount)
+{
+	ecsOrderComputeCount_ = ecsOrderComputeCount;
+	setParameter("EcsOrderComputeCount", std::to_string(ecsOrderComputeCount));
+}
+
+std::string CreateClusterRequest::getComputeSpotStrategy()const
+{
+	return computeSpotStrategy_;
+}
+
+void CreateClusterRequest::setComputeSpotStrategy(const std::string& computeSpotStrategy)
+{
+	computeSpotStrategy_ = computeSpotStrategy;
+	setParameter("ComputeSpotStrategy", computeSpotStrategy);
+}
+
+std::string CreateClusterRequest::getVSwitchId()const
+{
+	return vSwitchId_;
+}
+
+void CreateClusterRequest::setVSwitchId(const std::string& vSwitchId)
+{
+	vSwitchId_ = vSwitchId;
+	setParameter("VSwitchId", vSwitchId);
+}
+
+std::vector<CreateClusterRequest::Application> CreateClusterRequest::getApplication()const
+{
+	return application_;
+}
+
+void CreateClusterRequest::setApplication(const std::vector<Application>& application)
+{
+	application_ = application;
+	int i = 0;
+	for(int i = 0; i!= application.size(); i++)	{
+		auto obj = application.at(i);
+		std::string str ="Application."+ std::to_string(i);
+		setParameter(str + ".Tag", obj.tag);
+	}
+}
+
+std::string CreateClusterRequest::getEcsChargeType()const
+{
+	return ecsChargeType_;
+}
+
+void CreateClusterRequest::setEcsChargeType(const std::string& ecsChargeType)
+{
+	ecsChargeType_ = ecsChargeType;
+	setParameter("EcsChargeType", ecsChargeType);
+}
+
+bool CreateClusterRequest::getHaEnable()const
+{
+	return haEnable_;
+}
+
+void CreateClusterRequest::setHaEnable(bool haEnable)
+{
+	haEnable_ = haEnable;
+	setParameter("HaEnable", std::to_string(haEnable));
+}
+
+std::string CreateClusterRequest::getName()const
+{
+	return name_;
+}
+
+void CreateClusterRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string CreateClusterRequest::getSchedulerType()const
+{
+	return schedulerType_;
+}
+
+void CreateClusterRequest::setSchedulerType(const std::string& schedulerType)
+{
+	schedulerType_ = schedulerType;
+	setParameter("SchedulerType", schedulerType);
+}
+
+std::string CreateClusterRequest::getVolumeId()const
+{
+	return volumeId_;
+}
+
+void CreateClusterRequest::setVolumeId(const std::string& volumeId)
+{
+	volumeId_ = volumeId;
+	setParameter("VolumeId", volumeId);
+}
+
+std::string CreateClusterRequest::getVolumeMountpoint()const
+{
+	return volumeMountpoint_;
+}
+
+void CreateClusterRequest::setVolumeMountpoint(const std::string& volumeMountpoint)
+{
+	volumeMountpoint_ = volumeMountpoint;
+	setParameter("VolumeMountpoint", volumeMountpoint);
+}
+
+std::string CreateClusterRequest::getEcsOrderLoginInstanceType()const
+{
+	return ecsOrderLoginInstanceType_;
+}
+
+void CreateClusterRequest::setEcsOrderLoginInstanceType(const std::string& ecsOrderLoginInstanceType)
+{
+	ecsOrderLoginInstanceType_ = ecsOrderLoginInstanceType;
+	setParameter("EcsOrderLoginInstanceType", ecsOrderLoginInstanceType);
+}
+
+std::string CreateClusterRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void CreateClusterRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+

ehpc/src/model/CreateClusterResult.cc

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

ehpc/src/model/CreateJobTemplateRequest.cc

@@ -0,0 +1,159 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ehpc/model/CreateJobTemplateRequest.h>
+
+using AlibabaCloud::EHPC::Model::CreateJobTemplateRequest;
+
+CreateJobTemplateRequest::CreateJobTemplateRequest() :
+	RpcServiceRequest("ehpc", "2017-07-14", "CreateJobTemplate")
+{}
+
+CreateJobTemplateRequest::~CreateJobTemplateRequest()
+{}
+
+std::string CreateJobTemplateRequest::getStderrRedirectPath()const
+{
+	return stderrRedirectPath_;
+}
+
+void CreateJobTemplateRequest::setStderrRedirectPath(const std::string& stderrRedirectPath)
+{
+	stderrRedirectPath_ = stderrRedirectPath;
+	setParameter("StderrRedirectPath", stderrRedirectPath);
+}
+
+std::string CreateJobTemplateRequest::getVariables()const
+{
+	return variables_;
+}
+
+void CreateJobTemplateRequest::setVariables(const std::string& variables)
+{
+	variables_ = variables;
+	setParameter("Variables", variables);
+}
+
+std::string CreateJobTemplateRequest::getRunasUser()const
+{
+	return runasUser_;
+}
+
+void CreateJobTemplateRequest::setRunasUser(const std::string& runasUser)
+{
+	runasUser_ = runasUser;
+	setParameter("RunasUser", runasUser);
+}
+
+bool CreateJobTemplateRequest::getReRunable()const
+{
+	return reRunable_;
+}
+
+void CreateJobTemplateRequest::setReRunable(bool reRunable)
+{
+	reRunable_ = reRunable;
+	setParameter("ReRunable", std::to_string(reRunable));
+}
+
+int CreateJobTemplateRequest::getPriority()const
+{
+	return priority_;
+}
+
+void CreateJobTemplateRequest::setPriority(int priority)
+{
+	priority_ = priority;
+	setParameter("Priority", std::to_string(priority));
+}
+
+std::string CreateJobTemplateRequest::getCommandLine()const
+{
+	return commandLine_;
+}
+
+void CreateJobTemplateRequest::setCommandLine(const std::string& commandLine)
+{
+	commandLine_ = commandLine;
+	setParameter("CommandLine", commandLine);
+}
+
+std::string CreateJobTemplateRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CreateJobTemplateRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CreateJobTemplateRequest::getArrayRequest()const
+{
+	return arrayRequest_;
+}
+
+void CreateJobTemplateRequest::setArrayRequest(const std::string& arrayRequest)
+{
+	arrayRequest_ = arrayRequest;
+	setParameter("ArrayRequest", arrayRequest);
+}
+
+std::string CreateJobTemplateRequest::getPackagePath()const
+{
+	return packagePath_;
+}
+
+void CreateJobTemplateRequest::setPackagePath(const std::string& packagePath)
+{
+	packagePath_ = packagePath;
+	setParameter("PackagePath", packagePath);
+}
+
+std::string CreateJobTemplateRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CreateJobTemplateRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CreateJobTemplateRequest::getName()const
+{
+	return name_;
+}
+
+void CreateJobTemplateRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string CreateJobTemplateRequest::getStdoutRedirectPath()const
+{
+	return stdoutRedirectPath_;
+}
+
+void CreateJobTemplateRequest::setStdoutRedirectPath(const std::string& stdoutRedirectPath)
+{
+	stdoutRedirectPath_ = stdoutRedirectPath;
+	setParameter("StdoutRedirectPath", stdoutRedirectPath);
+}
+

ehpc/src/model/CreateJobTemplateResult.cc

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

ehpc/src/model/DeleteClusterRequest.cc

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DeleteClusterRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteClusterRequest;
+
+DeleteClusterRequest::DeleteClusterRequest() :
+	RpcServiceRequest("ehpc", "2017-07-14", "DeleteCluster")
+{}
+
+DeleteClusterRequest::~DeleteClusterRequest()
+{}
+
+std::string DeleteClusterRequest::getReleaseInstance()const
+{
+	return releaseInstance_;
+}
+
+void DeleteClusterRequest::setReleaseInstance(const std::string& releaseInstance)
+{
+	releaseInstance_ = releaseInstance;
+	setParameter("ReleaseInstance", releaseInstance);
+}
+
+std::string DeleteClusterRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DeleteClusterRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string DeleteClusterRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteClusterRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

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

ehpc/src/model/DeleteJobTemplatesRequest.cc

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DeleteJobTemplatesRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteJobTemplatesRequest;
+
+DeleteJobTemplatesRequest::DeleteJobTemplatesRequest() :
+	RpcServiceRequest("ehpc", "2017-07-14", "DeleteJobTemplates")
+{}
+
+DeleteJobTemplatesRequest::~DeleteJobTemplatesRequest()
+{}
+
+std::string DeleteJobTemplatesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DeleteJobTemplatesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string DeleteJobTemplatesRequest::getTemplates()const
+{
+	return templates_;
+}
+
+void DeleteJobTemplatesRequest::setTemplates(const std::string& templates)
+{
+	templates_ = templates;
+	setParameter("Templates", templates);
+}
+
+std::string DeleteJobTemplatesRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteJobTemplatesRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

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

ehpc/src/model/DeleteJobsRequest.cc

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DeleteJobsRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteJobsRequest;
+
+DeleteJobsRequest::DeleteJobsRequest() :
+	RpcServiceRequest("ehpc", "2017-07-14", "DeleteJobs")
+{}
+
+DeleteJobsRequest::~DeleteJobsRequest()
+{}
+
+std::string DeleteJobsRequest::getJobs()const
+{
+	return jobs_;
+}
+
+void DeleteJobsRequest::setJobs(const std::string& jobs)
+{
+	jobs_ = jobs;
+	setParameter("Jobs", jobs);
+}
+
+std::string DeleteJobsRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DeleteJobsRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string DeleteJobsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteJobsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

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

ehpc/src/model/DeleteNodesRequest.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/ehpc/model/DeleteNodesRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteNodesRequest;
+
+DeleteNodesRequest::DeleteNodesRequest() :
+	RpcServiceRequest("ehpc", "2017-07-14", "DeleteNodes")
+{}
+
+DeleteNodesRequest::~DeleteNodesRequest()
+{}
+
+bool DeleteNodesRequest::getReleaseInstance()const
+{
+	return releaseInstance_;
+}
+
+void DeleteNodesRequest::setReleaseInstance(bool releaseInstance)
+{
+	releaseInstance_ = releaseInstance;
+	setParameter("ReleaseInstance", std::to_string(releaseInstance));
+}
+
+std::vector<DeleteNodesRequest::Instance> DeleteNodesRequest::getInstance()const
+{
+	return instance_;
+}
+
+void DeleteNodesRequest::setInstance(const std::vector<Instance>& instance)
+{
+	instance_ = instance;
+	int i = 0;
+	for(int i = 0; i!= instance.size(); i++)	{
+		auto obj = instance.at(i);
+		std::string str ="Instance."+ std::to_string(i);
+		setParameter(str + ".Id", obj.id);
+	}
+}
+
+std::string DeleteNodesRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DeleteNodesRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string DeleteNodesRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteNodesRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

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

ehpc/src/model/DeleteUsersRequest.cc

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DeleteUsersRequest.h>
+
+using AlibabaCloud::EHPC::Model::DeleteUsersRequest;
+
+DeleteUsersRequest::DeleteUsersRequest() :
+	RpcServiceRequest("ehpc", "2017-07-14", "DeleteUsers")
+{}
+
+DeleteUsersRequest::~DeleteUsersRequest()
+{}
+
+std::string DeleteUsersRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DeleteUsersRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::vector<DeleteUsersRequest::User> DeleteUsersRequest::getUser()const
+{
+	return user_;
+}
+
+void DeleteUsersRequest::setUser(const std::vector<User>& user)
+{
+	user_ = user;
+	int i = 0;
+	for(int i = 0; i!= user.size(); i++)	{
+		auto obj = user.at(i);
+		std::string str ="User."+ std::to_string(i);
+		setParameter(str + ".Name", obj.name);
+	}
+}
+
+std::string DeleteUsersRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DeleteUsersRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

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

ehpc/src/model/DescribeClusterRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/ehpc/model/DescribeClusterRequest.h>
+
+using AlibabaCloud::EHPC::Model::DescribeClusterRequest;
+
+DescribeClusterRequest::DescribeClusterRequest() :
+	RpcServiceRequest("ehpc", "2017-07-14", "DescribeCluster")
+{}
+
+DescribeClusterRequest::~DescribeClusterRequest()
+{}
+
+std::string DescribeClusterRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DescribeClusterRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+
+std::string DescribeClusterRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeClusterRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

ehpc/src/model/DescribeClusterResult.cc

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ehpc/model/DescribeClusterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::EHPC;
+using namespace AlibabaCloud::EHPC::Model;
+
+DescribeClusterResult::DescribeClusterResult() :
+	ServiceResult()
+{}
+
+DescribeClusterResult::DescribeClusterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeClusterResult::~DescribeClusterResult()
+{}
+
+void DescribeClusterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allClusterInfo = value["ClusterInfo"];
+	for (auto value : allClusterInfo)
+	{
+		ClusterInfo clusterInfoObject;
+		if(!value["Id"].isNull())
+			clusterInfoObject.id = value["Id"].asString();
+		if(!value["RegionId"].isNull())
+			clusterInfoObject.regionId = value["RegionId"].asString();
+		if(!value["Name"].isNull())
+			clusterInfoObject.name = value["Name"].asString();
+		if(!value["Description"].isNull())
+			clusterInfoObject.description = value["Description"].asString();
+		if(!value["Status"].isNull())
+			clusterInfoObject.status = value["Status"].asString();
+		if(!value["OsTag"].isNull())
+			clusterInfoObject.osTag = value["OsTag"].asString();
+		if(!value["AccountType"].isNull())
+			clusterInfoObject.accountType = value["AccountType"].asString();
+		if(!value["SchedulerType"].isNull())
+			clusterInfoObject.schedulerType = value["SchedulerType"].asString();
+		if(!value["CreateTime"].isNull())
+			clusterInfoObject.createTime = value["CreateTime"].asString();
+		if(!value["SecurityGroupId"].isNull())
+			clusterInfoObject.securityGroupId = value["SecurityGroupId"].asString();
+		if(!value["VSwitchId"].isNull())
+			clusterInfoObject.vSwitchId = value["VSwitchId"].asString();
+		if(!value["VolumeType"].isNull())
+			clusterInfoObject.volumeType = value["VolumeType"].asString();
+		if(!value["VolumeId"].isNull())
+			clusterInfoObject.volumeId = value["VolumeId"].asString();
+		if(!value["VolumeProtocol"].isNull())
+			clusterInfoObject.volumeProtocol = value["VolumeProtocol"].asString();
+		if(!value["VolumeMountpoint"].isNull())
+			clusterInfoObject.volumeMountpoint = value["VolumeMountpoint"].asString();
+		if(!value["RemoteDirectory"].isNull())
+			clusterInfoObject.remoteDirectory = value["RemoteDirectory"].asString();
+		if(!value["HaEnable"].isNull())
+			clusterInfoObject.haEnable = value["HaEnable"].asString() == "true";
+		if(!value["EcsChargeType"].isNull())
+			clusterInfoObject.ecsChargeType = value["EcsChargeType"].asString();
+		if(!value["KeyPairName"].isNull())
+			clusterInfoObject.keyPairName = value["KeyPairName"].asString();
+		if(!value["SccClusterId"].isNull())
+			clusterInfoObject.sccClusterId = value["SccClusterId"].asString();
+		if(!value["ClientVersion"].isNull())
+			clusterInfoObject.clientVersion = value["ClientVersion"].asString();
+		if(!value["ImageOwnerAlias"].isNull())
+			clusterInfoObject.imageOwnerAlias = value["ImageOwnerAlias"].asString();
+		if(!value["ImageId"].isNull())
+			clusterInfoObject.imageId = value["ImageId"].asString();
+		auto allApplicationInfo = value["ApplicationInfo"]["ApplicationInfoItem"];
+		for (auto value : allApplicationInfo)
+		{
+			ClusterInfo::ApplicationInfoItem applicationInfoItemObject;
+			if(!value["Tag"].isNull())
+				applicationInfoItemObject.tag = value["Tag"].asString();
+			if(!value["Name"].isNull())
+				applicationInfoItemObject.name = value["Name"].asString();
+			if(!value["Version"].isNull())
+				applicationInfoItemObject.version = value["Version"].asString();
+			clusterInfoObject.applicationInfo.push_back(applicationInfoItemObject);
+		}
+		auto allEcsInfo = value["EcsInfo"];
+		for (auto value : allEcsInfo)
+		{
+			ClusterInfo::EcsInfo ecsInfoObject;
+			auto allManager = value["Manager"];
+			for (auto value : allManager)
+			{
+				ClusterInfo::EcsInfo::Manager managerObject;
+				if(!value["Count"].isNull())
+					managerObject.count = std::stoi(value["Count"].asString());
+				if(!value["InstanceType"].isNull())
+					managerObject.instanceType = value["InstanceType"].asString();
+				ecsInfoObject.manager.push_back(managerObject);
+			}
+			auto allCompute = value["Compute"];
+			for (auto value : allCompute)
+			{
+				ClusterInfo::EcsInfo::Compute computeObject;
+				if(!value["Count"].isNull())
+					computeObject.count = std::stoi(value["Count"].asString());
+				if(!value["InstanceType"].isNull())
+					computeObject.instanceType = value["InstanceType"].asString();
+				ecsInfoObject.compute.push_back(computeObject);
+			}
+			auto allLogin = value["Login"];
+			for (auto value : allLogin)
+			{
+				ClusterInfo::EcsInfo::Login loginObject;
+				if(!value["Count"].isNull())
+					loginObject.count = std::stoi(value["Count"].asString());
+				if(!value["InstanceType"].isNull())
+					loginObject.instanceType = value["InstanceType"].asString();
+				ecsInfoObject.login.push_back(loginObject);
+			}
+			clusterInfoObject.ecsInfo.push_back(ecsInfoObject);
+		}
+		clusterInfo_.push_back(clusterInfoObject);
+	}
+
+}
+
+std::vector<DescribeClusterResult::ClusterInfo> DescribeClusterResult::getClusterInfo()const
+{
+	return clusterInfo_;
+}
+

ehpc/src/model/EditJobTemplateRequest.cc

@@ -0,0 +1,170 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ehpc/model/EditJobTemplateRequest.h>
+
+using AlibabaCloud::EHPC::Model::EditJobTemplateRequest;
+
+EditJobTemplateRequest::EditJobTemplateRequest() :
+	RpcServiceRequest("ehpc", "2017-07-14", "EditJobTemplate")
+{}
+
+EditJobTemplateRequest::~EditJobTemplateRequest()
+{}
+
+std::string EditJobTemplateRequest::getStderrRedirectPath()const
+{
+	return stderrRedirectPath_;
+}
+
+void EditJobTemplateRequest::setStderrRedirectPath(const std::string& stderrRedirectPath)
+{
+	stderrRedirectPath_ = stderrRedirectPath;
+	setParameter("StderrRedirectPath", stderrRedirectPath);
+}
+
+std::string EditJobTemplateRequest::getVariables()const
+{
+	return variables_;
+}
+
+void EditJobTemplateRequest::setVariables(const std::string& variables)
+{
+	variables_ = variables;
+	setParameter("Variables", variables);
+}
+
+std::string EditJobTemplateRequest::getRunasUser()const
+{
+	return runasUser_;
+}
+
+void EditJobTemplateRequest::setRunasUser(const std::string& runasUser)
+{
+	runasUser_ = runasUser;
+	setParameter("RunasUser", runasUser);
+}
+
+std::string EditJobTemplateRequest::getTemplateId()const
+{
+	return templateId_;
+}
+
+void EditJobTemplateRequest::setTemplateId(const std::string& templateId)
+{
+	templateId_ = templateId;
+	setParameter("TemplateId", templateId);
+}
+
+int EditJobTemplateRequest::getPriority()const
+{
+	return priority_;
+}
+
+void EditJobTemplateRequest::setPriority(int priority)
+{
+	priority_ = priority;
+	setParameter("Priority", std::to_string(priority));
+}
+
+std::string EditJobTemplateRequest::getCommandLine()const
+{
+	return commandLine_;
+}
+
+void EditJobTemplateRequest::setCommandLine(const std::string& commandLine)
+{
+	commandLine_ = commandLine;
+	setParameter("CommandLine", commandLine);
+}
+
+std::string EditJobTemplateRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void EditJobTemplateRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string EditJobTemplateRequest::getArrayRequest()const
+{
+	return arrayRequest_;
+}
+
+void EditJobTemplateRequest::setArrayRequest(const std::string& arrayRequest)
+{
+	arrayRequest_ = arrayRequest;
+	setParameter("ArrayRequest", arrayRequest);
+}
+
+std::string EditJobTemplateRequest::getPackagePath()const
+{
+	return packagePath_;
+}
+
+void EditJobTemplateRequest::setPackagePath(const std::string& packagePath)
+{
+	packagePath_ = packagePath;
+	setParameter("PackagePath", packagePath);
+}
+
+bool EditJobTemplateRequest::getReRunnable()const
+{
+	return reRunnable_;
+}
+
+void EditJobTemplateRequest::setReRunnable(bool reRunnable)
+{
+	reRunnable_ = reRunnable;
+	setParameter("ReRunnable", std::to_string(reRunnable));
+}
+
+std::string EditJobTemplateRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void EditJobTemplateRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string EditJobTemplateRequest::getName()const
+{
+	return name_;
+}
+
+void EditJobTemplateRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string EditJobTemplateRequest::getStdoutRedirectPath()const
+{
+	return stdoutRedirectPath_;
+}
+
+void EditJobTemplateRequest::setStdoutRedirectPath(const std::string& stdoutRedirectPath)
+{
+	stdoutRedirectPath_ = stdoutRedirectPath;
+	setParameter("StdoutRedirectPath", stdoutRedirectPath);
+}
+