ListNodesByQueue and ListJobsWithFilters add Async.

VERSION

@@ -1 +1 @@
-1.36.1313
+1.36.1314

ehpc/CMakeLists.txt

@@ -21,151 +21,535 @@ set(ehpc_public_header
 	include/alibabacloud/ehpc/EHPCExport.h )
 
 set(ehpc_public_header_model 
+	include/alibabacloud/ehpc/model/AddContainerAppRequest.h
+	include/alibabacloud/ehpc/model/AddContainerAppResult.h
+	include/alibabacloud/ehpc/model/AddExistedNodesRequest.h
+	include/alibabacloud/ehpc/model/AddExistedNodesResult.h
+	include/alibabacloud/ehpc/model/AddLocalNodesRequest.h
+	include/alibabacloud/ehpc/model/AddLocalNodesResult.h
 	include/alibabacloud/ehpc/model/AddNodesRequest.h
 	include/alibabacloud/ehpc/model/AddNodesResult.h
+	include/alibabacloud/ehpc/model/AddQueueRequest.h
+	include/alibabacloud/ehpc/model/AddQueueResult.h
+	include/alibabacloud/ehpc/model/AddSecurityGroupRequest.h
+	include/alibabacloud/ehpc/model/AddSecurityGroupResult.h
 	include/alibabacloud/ehpc/model/AddUsersRequest.h
 	include/alibabacloud/ehpc/model/AddUsersResult.h
+	include/alibabacloud/ehpc/model/ApplyNodesRequest.h
+	include/alibabacloud/ehpc/model/ApplyNodesResult.h
 	include/alibabacloud/ehpc/model/CreateClusterRequest.h
 	include/alibabacloud/ehpc/model/CreateClusterResult.h
+	include/alibabacloud/ehpc/model/CreateGWSClusterRequest.h
+	include/alibabacloud/ehpc/model/CreateGWSClusterResult.h
+	include/alibabacloud/ehpc/model/CreateGWSImageRequest.h
+	include/alibabacloud/ehpc/model/CreateGWSImageResult.h
+	include/alibabacloud/ehpc/model/CreateGWSInstanceRequest.h
+	include/alibabacloud/ehpc/model/CreateGWSInstanceResult.h
+	include/alibabacloud/ehpc/model/CreateHybridClusterRequest.h
+	include/alibabacloud/ehpc/model/CreateHybridClusterResult.h
+	include/alibabacloud/ehpc/model/CreateJobFileRequest.h
+	include/alibabacloud/ehpc/model/CreateJobFileResult.h
 	include/alibabacloud/ehpc/model/CreateJobTemplateRequest.h
 	include/alibabacloud/ehpc/model/CreateJobTemplateResult.h
 	include/alibabacloud/ehpc/model/DeleteClusterRequest.h
 	include/alibabacloud/ehpc/model/DeleteClusterResult.h
+	include/alibabacloud/ehpc/model/DeleteContainerAppsRequest.h
+	include/alibabacloud/ehpc/model/DeleteContainerAppsResult.h
+	include/alibabacloud/ehpc/model/DeleteGWSClusterRequest.h
+	include/alibabacloud/ehpc/model/DeleteGWSClusterResult.h
+	include/alibabacloud/ehpc/model/DeleteGWSInstanceRequest.h
+	include/alibabacloud/ehpc/model/DeleteGWSInstanceResult.h
+	include/alibabacloud/ehpc/model/DeleteImageRequest.h
+	include/alibabacloud/ehpc/model/DeleteImageResult.h
 	include/alibabacloud/ehpc/model/DeleteJobTemplatesRequest.h
 	include/alibabacloud/ehpc/model/DeleteJobTemplatesResult.h
 	include/alibabacloud/ehpc/model/DeleteJobsRequest.h
 	include/alibabacloud/ehpc/model/DeleteJobsResult.h
+	include/alibabacloud/ehpc/model/DeleteLocalImageRequest.h
+	include/alibabacloud/ehpc/model/DeleteLocalImageResult.h
 	include/alibabacloud/ehpc/model/DeleteNodesRequest.h
 	include/alibabacloud/ehpc/model/DeleteNodesResult.h
+	include/alibabacloud/ehpc/model/DeleteQueueRequest.h
+	include/alibabacloud/ehpc/model/DeleteQueueResult.h
+	include/alibabacloud/ehpc/model/DeleteSecurityGroupRequest.h
+	include/alibabacloud/ehpc/model/DeleteSecurityGroupResult.h
 	include/alibabacloud/ehpc/model/DeleteUsersRequest.h
 	include/alibabacloud/ehpc/model/DeleteUsersResult.h
+	include/alibabacloud/ehpc/model/DescribeAutoScaleConfigRequest.h
+	include/alibabacloud/ehpc/model/DescribeAutoScaleConfigResult.h
 	include/alibabacloud/ehpc/model/DescribeClusterRequest.h
 	include/alibabacloud/ehpc/model/DescribeClusterResult.h
+	include/alibabacloud/ehpc/model/DescribeContainerAppRequest.h
+	include/alibabacloud/ehpc/model/DescribeContainerAppResult.h
+	include/alibabacloud/ehpc/model/DescribeEstackImageRequest.h
+	include/alibabacloud/ehpc/model/DescribeEstackImageResult.h
+	include/alibabacloud/ehpc/model/DescribeGWSClusterPolicyRequest.h
+	include/alibabacloud/ehpc/model/DescribeGWSClusterPolicyResult.h
+	include/alibabacloud/ehpc/model/DescribeGWSClustersRequest.h
+	include/alibabacloud/ehpc/model/DescribeGWSClustersResult.h
+	include/alibabacloud/ehpc/model/DescribeGWSImagesRequest.h
+	include/alibabacloud/ehpc/model/DescribeGWSImagesResult.h
+	include/alibabacloud/ehpc/model/DescribeGWSInstancesRequest.h
+	include/alibabacloud/ehpc/model/DescribeGWSInstancesResult.h
+	include/alibabacloud/ehpc/model/DescribeImageRequest.h
+	include/alibabacloud/ehpc/model/DescribeImageResult.h
+	include/alibabacloud/ehpc/model/DescribeImageGatewayConfigRequest.h
+	include/alibabacloud/ehpc/model/DescribeImageGatewayConfigResult.h
+	include/alibabacloud/ehpc/model/DescribeImagePriceRequest.h
+	include/alibabacloud/ehpc/model/DescribeImagePriceResult.h
+	include/alibabacloud/ehpc/model/DescribeJobRequest.h
+	include/alibabacloud/ehpc/model/DescribeJobResult.h
+	include/alibabacloud/ehpc/model/DescribeNFSClientStatusRequest.h
+	include/alibabacloud/ehpc/model/DescribeNFSClientStatusResult.h
+	include/alibabacloud/ehpc/model/DescribePriceRequest.h
+	include/alibabacloud/ehpc/model/DescribePriceResult.h
 	include/alibabacloud/ehpc/model/EditJobTemplateRequest.h
 	include/alibabacloud/ehpc/model/EditJobTemplateResult.h
+	include/alibabacloud/ehpc/model/GetAccountingReportRequest.h
+	include/alibabacloud/ehpc/model/GetAccountingReportResult.h
 	include/alibabacloud/ehpc/model/GetAutoScaleConfigRequest.h
 	include/alibabacloud/ehpc/model/GetAutoScaleConfigResult.h
+	include/alibabacloud/ehpc/model/GetCloudMetricLogsRequest.h
+	include/alibabacloud/ehpc/model/GetCloudMetricLogsResult.h
+	include/alibabacloud/ehpc/model/GetCloudMetricProfilingRequest.h
+	include/alibabacloud/ehpc/model/GetCloudMetricProfilingResult.h
+	include/alibabacloud/ehpc/model/GetClusterVolumesRequest.h
+	include/alibabacloud/ehpc/model/GetClusterVolumesResult.h
+	include/alibabacloud/ehpc/model/GetCommonImageRequest.h
+	include/alibabacloud/ehpc/model/GetCommonImageResult.h
+	include/alibabacloud/ehpc/model/GetGWSConnectTicketRequest.h
+	include/alibabacloud/ehpc/model/GetGWSConnectTicketResult.h
+	include/alibabacloud/ehpc/model/GetHybridClusterConfigRequest.h
+	include/alibabacloud/ehpc/model/GetHybridClusterConfigResult.h
+	include/alibabacloud/ehpc/model/GetIfEcsTypeSupportHtConfigRequest.h
+	include/alibabacloud/ehpc/model/GetIfEcsTypeSupportHtConfigResult.h
+	include/alibabacloud/ehpc/model/GetPostScriptsRequest.h
+	include/alibabacloud/ehpc/model/GetPostScriptsResult.h
+	include/alibabacloud/ehpc/model/GetSchedulerInfoRequest.h
+	include/alibabacloud/ehpc/model/GetSchedulerInfoResult.h
+	include/alibabacloud/ehpc/model/GetUserImageRequest.h
+	include/alibabacloud/ehpc/model/GetUserImageResult.h
+	include/alibabacloud/ehpc/model/GetVisualServiceStatusRequest.h
+	include/alibabacloud/ehpc/model/GetVisualServiceStatusResult.h
+	include/alibabacloud/ehpc/model/InitializeEHPCRequest.h
+	include/alibabacloud/ehpc/model/InitializeEHPCResult.h
+	include/alibabacloud/ehpc/model/InspectImageRequest.h
+	include/alibabacloud/ehpc/model/InspectImageResult.h
+	include/alibabacloud/ehpc/model/InstallSoftwareRequest.h
+	include/alibabacloud/ehpc/model/InstallSoftwareResult.h
+	include/alibabacloud/ehpc/model/InvokeShellCommandRequest.h
+	include/alibabacloud/ehpc/model/InvokeShellCommandResult.h
+	include/alibabacloud/ehpc/model/ListAvailableEcsTypesRequest.h
+	include/alibabacloud/ehpc/model/ListAvailableEcsTypesResult.h
+	include/alibabacloud/ehpc/model/ListCloudMetricProfilingsRequest.h
+	include/alibabacloud/ehpc/model/ListCloudMetricProfilingsResult.h
 	include/alibabacloud/ehpc/model/ListClusterLogsRequest.h
 	include/alibabacloud/ehpc/model/ListClusterLogsResult.h
 	include/alibabacloud/ehpc/model/ListClustersRequest.h
 	include/alibabacloud/ehpc/model/ListClustersResult.h
+	include/alibabacloud/ehpc/model/ListClustersMetaRequest.h
+	include/alibabacloud/ehpc/model/ListClustersMetaResult.h
+	include/alibabacloud/ehpc/model/ListCommandsRequest.h
+	include/alibabacloud/ehpc/model/ListCommandsResult.h
+	include/alibabacloud/ehpc/model/ListCommunityImagesRequest.h
+	include/alibabacloud/ehpc/model/ListCommunityImagesResult.h
+	include/alibabacloud/ehpc/model/ListContainerAppsRequest.h
+	include/alibabacloud/ehpc/model/ListContainerAppsResult.h
+	include/alibabacloud/ehpc/model/ListContainerImagesRequest.h
+	include/alibabacloud/ehpc/model/ListContainerImagesResult.h
+	include/alibabacloud/ehpc/model/ListCpfsFileSystemsRequest.h
+	include/alibabacloud/ehpc/model/ListCpfsFileSystemsResult.h
 	include/alibabacloud/ehpc/model/ListCurrentClientVersionRequest.h
 	include/alibabacloud/ehpc/model/ListCurrentClientVersionResult.h
 	include/alibabacloud/ehpc/model/ListCustomImagesRequest.h
 	include/alibabacloud/ehpc/model/ListCustomImagesResult.h
+	include/alibabacloud/ehpc/model/ListFileSystemWithMountTargetsRequest.h
+	include/alibabacloud/ehpc/model/ListFileSystemWithMountTargetsResult.h
 	include/alibabacloud/ehpc/model/ListImagesRequest.h
 	include/alibabacloud/ehpc/model/ListImagesResult.h
+	include/alibabacloud/ehpc/model/ListInstalledSoftwareRequest.h
+	include/alibabacloud/ehpc/model/ListInstalledSoftwareResult.h
+	include/alibabacloud/ehpc/model/ListInvocationResultsRequest.h
+	include/alibabacloud/ehpc/model/ListInvocationResultsResult.h
+	include/alibabacloud/ehpc/model/ListInvocationStatusRequest.h
+	include/alibabacloud/ehpc/model/ListInvocationStatusResult.h
 	include/alibabacloud/ehpc/model/ListJobTemplatesRequest.h
 	include/alibabacloud/ehpc/model/ListJobTemplatesResult.h
 	include/alibabacloud/ehpc/model/ListJobsRequest.h
 	include/alibabacloud/ehpc/model/ListJobsResult.h
+	include/alibabacloud/ehpc/model/ListJobsWithFiltersRequest.h
+	include/alibabacloud/ehpc/model/ListJobsWithFiltersResult.h
 	include/alibabacloud/ehpc/model/ListNodesRequest.h
 	include/alibabacloud/ehpc/model/ListNodesResult.h
+	include/alibabacloud/ehpc/model/ListNodesByQueueRequest.h
+	include/alibabacloud/ehpc/model/ListNodesByQueueResult.h
 	include/alibabacloud/ehpc/model/ListNodesNoPagingRequest.h
 	include/alibabacloud/ehpc/model/ListNodesNoPagingResult.h
 	include/alibabacloud/ehpc/model/ListPreferredEcsTypesRequest.h
 	include/alibabacloud/ehpc/model/ListPreferredEcsTypesResult.h
+	include/alibabacloud/ehpc/model/ListQueuesRequest.h
+	include/alibabacloud/ehpc/model/ListQueuesResult.h
 	include/alibabacloud/ehpc/model/ListRegionsRequest.h
 	include/alibabacloud/ehpc/model/ListRegionsResult.h
+	include/alibabacloud/ehpc/model/ListSecurityGroupsRequest.h
+	include/alibabacloud/ehpc/model/ListSecurityGroupsResult.h
 	include/alibabacloud/ehpc/model/ListSoftwaresRequest.h
 	include/alibabacloud/ehpc/model/ListSoftwaresResult.h
+	include/alibabacloud/ehpc/model/ListTagResourcesRequest.h
+	include/alibabacloud/ehpc/model/ListTagResourcesResult.h
+	include/alibabacloud/ehpc/model/ListTasksRequest.h
+	include/alibabacloud/ehpc/model/ListTasksResult.h
+	include/alibabacloud/ehpc/model/ListUpgradeClientsRequest.h
+	include/alibabacloud/ehpc/model/ListUpgradeClientsResult.h
 	include/alibabacloud/ehpc/model/ListUsersRequest.h
 	include/alibabacloud/ehpc/model/ListUsersResult.h
+	include/alibabacloud/ehpc/model/ListUsersAsyncRequest.h
+	include/alibabacloud/ehpc/model/ListUsersAsyncResult.h
 	include/alibabacloud/ehpc/model/ListVolumesRequest.h
 	include/alibabacloud/ehpc/model/ListVolumesResult.h
 	include/alibabacloud/ehpc/model/ModifyClusterAttributesRequest.h
 	include/alibabacloud/ehpc/model/ModifyClusterAttributesResult.h
+	include/alibabacloud/ehpc/model/ModifyContainerAppAttributesRequest.h
+	include/alibabacloud/ehpc/model/ModifyContainerAppAttributesResult.h
+	include/alibabacloud/ehpc/model/ModifyImageGatewayConfigRequest.h
+	include/alibabacloud/ehpc/model/ModifyImageGatewayConfigResult.h
 	include/alibabacloud/ehpc/model/ModifyUserGroupsRequest.h
 	include/alibabacloud/ehpc/model/ModifyUserGroupsResult.h
 	include/alibabacloud/ehpc/model/ModifyUserPasswordsRequest.h
 	include/alibabacloud/ehpc/model/ModifyUserPasswordsResult.h
+	include/alibabacloud/ehpc/model/ModifyVisualServicePasswdRequest.h
+	include/alibabacloud/ehpc/model/ModifyVisualServicePasswdResult.h
+	include/alibabacloud/ehpc/model/MountNFSRequest.h
+	include/alibabacloud/ehpc/model/MountNFSResult.h
+	include/alibabacloud/ehpc/model/PullImageRequest.h
+	include/alibabacloud/ehpc/model/PullImageResult.h
+	include/alibabacloud/ehpc/model/QueryServicePackAndPriceRequest.h
+	include/alibabacloud/ehpc/model/QueryServicePackAndPriceResult.h
+	include/alibabacloud/ehpc/model/RecoverClusterRequest.h
+	include/alibabacloud/ehpc/model/RecoverClusterResult.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/RunCloudMetricProfilingRequest.h
+	include/alibabacloud/ehpc/model/RunCloudMetricProfilingResult.h
 	include/alibabacloud/ehpc/model/SetAutoScaleConfigRequest.h
 	include/alibabacloud/ehpc/model/SetAutoScaleConfigResult.h
-	include/alibabacloud/ehpc/model/SetJobUserRequest.h
-	include/alibabacloud/ehpc/model/SetJobUserResult.h
+	include/alibabacloud/ehpc/model/SetGWSClusterPolicyRequest.h
+	include/alibabacloud/ehpc/model/SetGWSClusterPolicyResult.h
+	include/alibabacloud/ehpc/model/SetGWSInstanceNameRequest.h
+	include/alibabacloud/ehpc/model/SetGWSInstanceNameResult.h
+	include/alibabacloud/ehpc/model/SetGWSInstanceUserRequest.h
+	include/alibabacloud/ehpc/model/SetGWSInstanceUserResult.h
+	include/alibabacloud/ehpc/model/SetPostScriptsRequest.h
+	include/alibabacloud/ehpc/model/SetPostScriptsResult.h
+	include/alibabacloud/ehpc/model/SetQueueRequest.h
+	include/alibabacloud/ehpc/model/SetQueueResult.h
+	include/alibabacloud/ehpc/model/SetSchedulerInfoRequest.h
+	include/alibabacloud/ehpc/model/SetSchedulerInfoResult.h
+	include/alibabacloud/ehpc/model/StartClusterRequest.h
+	include/alibabacloud/ehpc/model/StartClusterResult.h
+	include/alibabacloud/ehpc/model/StartGWSInstanceRequest.h
+	include/alibabacloud/ehpc/model/StartGWSInstanceResult.h
+	include/alibabacloud/ehpc/model/StartNodesRequest.h
+	include/alibabacloud/ehpc/model/StartNodesResult.h
+	include/alibabacloud/ehpc/model/StartVisualServiceRequest.h
+	include/alibabacloud/ehpc/model/StartVisualServiceResult.h
+	include/alibabacloud/ehpc/model/StopClusterRequest.h
+	include/alibabacloud/ehpc/model/StopClusterResult.h
+	include/alibabacloud/ehpc/model/StopGWSInstanceRequest.h
+	include/alibabacloud/ehpc/model/StopGWSInstanceResult.h
 	include/alibabacloud/ehpc/model/StopJobsRequest.h
 	include/alibabacloud/ehpc/model/StopJobsResult.h
+	include/alibabacloud/ehpc/model/StopNodesRequest.h
+	include/alibabacloud/ehpc/model/StopNodesResult.h
+	include/alibabacloud/ehpc/model/StopVisualServiceRequest.h
+	include/alibabacloud/ehpc/model/StopVisualServiceResult.h
 	include/alibabacloud/ehpc/model/SubmitJobRequest.h
 	include/alibabacloud/ehpc/model/SubmitJobResult.h
+	include/alibabacloud/ehpc/model/SummaryImagesRequest.h
+	include/alibabacloud/ehpc/model/SummaryImagesResult.h
+	include/alibabacloud/ehpc/model/SummaryImagesInfoRequest.h
+	include/alibabacloud/ehpc/model/SummaryImagesInfoResult.h
+	include/alibabacloud/ehpc/model/SyncUsersRequest.h
+	include/alibabacloud/ehpc/model/SyncUsersResult.h
+	include/alibabacloud/ehpc/model/TagResourcesRequest.h
+	include/alibabacloud/ehpc/model/TagResourcesResult.h
+	include/alibabacloud/ehpc/model/UnTagResourcesRequest.h
+	include/alibabacloud/ehpc/model/UnTagResourcesResult.h
+	include/alibabacloud/ehpc/model/UninstallSoftwareRequest.h
+	include/alibabacloud/ehpc/model/UninstallSoftwareResult.h
+	include/alibabacloud/ehpc/model/UpdateClusterVolumesRequest.h
+	include/alibabacloud/ehpc/model/UpdateClusterVolumesResult.h
+	include/alibabacloud/ehpc/model/UpdateQueueConfigRequest.h
+	include/alibabacloud/ehpc/model/UpdateQueueConfigResult.h
 	include/alibabacloud/ehpc/model/UpgradeClientRequest.h
 	include/alibabacloud/ehpc/model/UpgradeClientResult.h )
 
 set(ehpc_src 
 	src/EHPCClient.cc
+	src/model/AddContainerAppRequest.cc
+	src/model/AddContainerAppResult.cc
+	src/model/AddExistedNodesRequest.cc
+	src/model/AddExistedNodesResult.cc
+	src/model/AddLocalNodesRequest.cc
+	src/model/AddLocalNodesResult.cc
 	src/model/AddNodesRequest.cc
 	src/model/AddNodesResult.cc
+	src/model/AddQueueRequest.cc
+	src/model/AddQueueResult.cc
+	src/model/AddSecurityGroupRequest.cc
+	src/model/AddSecurityGroupResult.cc
 	src/model/AddUsersRequest.cc
 	src/model/AddUsersResult.cc
+	src/model/ApplyNodesRequest.cc
+	src/model/ApplyNodesResult.cc
 	src/model/CreateClusterRequest.cc
 	src/model/CreateClusterResult.cc
+	src/model/CreateGWSClusterRequest.cc
+	src/model/CreateGWSClusterResult.cc
+	src/model/CreateGWSImageRequest.cc
+	src/model/CreateGWSImageResult.cc
+	src/model/CreateGWSInstanceRequest.cc
+	src/model/CreateGWSInstanceResult.cc
+	src/model/CreateHybridClusterRequest.cc
+	src/model/CreateHybridClusterResult.cc
+	src/model/CreateJobFileRequest.cc
+	src/model/CreateJobFileResult.cc
 	src/model/CreateJobTemplateRequest.cc
 	src/model/CreateJobTemplateResult.cc
 	src/model/DeleteClusterRequest.cc
 	src/model/DeleteClusterResult.cc
+	src/model/DeleteContainerAppsRequest.cc
+	src/model/DeleteContainerAppsResult.cc
+	src/model/DeleteGWSClusterRequest.cc
+	src/model/DeleteGWSClusterResult.cc
+	src/model/DeleteGWSInstanceRequest.cc
+	src/model/DeleteGWSInstanceResult.cc
+	src/model/DeleteImageRequest.cc
+	src/model/DeleteImageResult.cc
 	src/model/DeleteJobTemplatesRequest.cc
 	src/model/DeleteJobTemplatesResult.cc
 	src/model/DeleteJobsRequest.cc
 	src/model/DeleteJobsResult.cc
+	src/model/DeleteLocalImageRequest.cc
+	src/model/DeleteLocalImageResult.cc
 	src/model/DeleteNodesRequest.cc
 	src/model/DeleteNodesResult.cc
+	src/model/DeleteQueueRequest.cc
+	src/model/DeleteQueueResult.cc
+	src/model/DeleteSecurityGroupRequest.cc
+	src/model/DeleteSecurityGroupResult.cc
 	src/model/DeleteUsersRequest.cc
 	src/model/DeleteUsersResult.cc
+	src/model/DescribeAutoScaleConfigRequest.cc
+	src/model/DescribeAutoScaleConfigResult.cc
 	src/model/DescribeClusterRequest.cc
 	src/model/DescribeClusterResult.cc
+	src/model/DescribeContainerAppRequest.cc
+	src/model/DescribeContainerAppResult.cc
+	src/model/DescribeEstackImageRequest.cc
+	src/model/DescribeEstackImageResult.cc
+	src/model/DescribeGWSClusterPolicyRequest.cc
+	src/model/DescribeGWSClusterPolicyResult.cc
+	src/model/DescribeGWSClustersRequest.cc
+	src/model/DescribeGWSClustersResult.cc
+	src/model/DescribeGWSImagesRequest.cc
+	src/model/DescribeGWSImagesResult.cc
+	src/model/DescribeGWSInstancesRequest.cc
+	src/model/DescribeGWSInstancesResult.cc
+	src/model/DescribeImageRequest.cc
+	src/model/DescribeImageResult.cc
+	src/model/DescribeImageGatewayConfigRequest.cc
+	src/model/DescribeImageGatewayConfigResult.cc
+	src/model/DescribeImagePriceRequest.cc
+	src/model/DescribeImagePriceResult.cc
+	src/model/DescribeJobRequest.cc
+	src/model/DescribeJobResult.cc
+	src/model/DescribeNFSClientStatusRequest.cc
+	src/model/DescribeNFSClientStatusResult.cc
+	src/model/DescribePriceRequest.cc
+	src/model/DescribePriceResult.cc
 	src/model/EditJobTemplateRequest.cc
 	src/model/EditJobTemplateResult.cc
+	src/model/GetAccountingReportRequest.cc
+	src/model/GetAccountingReportResult.cc
 	src/model/GetAutoScaleConfigRequest.cc
 	src/model/GetAutoScaleConfigResult.cc
+	src/model/GetCloudMetricLogsRequest.cc
+	src/model/GetCloudMetricLogsResult.cc
+	src/model/GetCloudMetricProfilingRequest.cc
+	src/model/GetCloudMetricProfilingResult.cc
+	src/model/GetClusterVolumesRequest.cc
+	src/model/GetClusterVolumesResult.cc
+	src/model/GetCommonImageRequest.cc
+	src/model/GetCommonImageResult.cc
+	src/model/GetGWSConnectTicketRequest.cc
+	src/model/GetGWSConnectTicketResult.cc
+	src/model/GetHybridClusterConfigRequest.cc
+	src/model/GetHybridClusterConfigResult.cc
+	src/model/GetIfEcsTypeSupportHtConfigRequest.cc
+	src/model/GetIfEcsTypeSupportHtConfigResult.cc
+	src/model/GetPostScriptsRequest.cc
+	src/model/GetPostScriptsResult.cc
+	src/model/GetSchedulerInfoRequest.cc
+	src/model/GetSchedulerInfoResult.cc
+	src/model/GetUserImageRequest.cc
+	src/model/GetUserImageResult.cc
+	src/model/GetVisualServiceStatusRequest.cc
+	src/model/GetVisualServiceStatusResult.cc
+	src/model/InitializeEHPCRequest.cc
+	src/model/InitializeEHPCResult.cc
+	src/model/InspectImageRequest.cc
+	src/model/InspectImageResult.cc
+	src/model/InstallSoftwareRequest.cc
+	src/model/InstallSoftwareResult.cc
+	src/model/InvokeShellCommandRequest.cc
+	src/model/InvokeShellCommandResult.cc
+	src/model/ListAvailableEcsTypesRequest.cc
+	src/model/ListAvailableEcsTypesResult.cc
+	src/model/ListCloudMetricProfilingsRequest.cc
+	src/model/ListCloudMetricProfilingsResult.cc
 	src/model/ListClusterLogsRequest.cc
 	src/model/ListClusterLogsResult.cc
 	src/model/ListClustersRequest.cc
 	src/model/ListClustersResult.cc
+	src/model/ListClustersMetaRequest.cc
+	src/model/ListClustersMetaResult.cc
+	src/model/ListCommandsRequest.cc
+	src/model/ListCommandsResult.cc
+	src/model/ListCommunityImagesRequest.cc
+	src/model/ListCommunityImagesResult.cc
+	src/model/ListContainerAppsRequest.cc
+	src/model/ListContainerAppsResult.cc
+	src/model/ListContainerImagesRequest.cc
+	src/model/ListContainerImagesResult.cc
+	src/model/ListCpfsFileSystemsRequest.cc
+	src/model/ListCpfsFileSystemsResult.cc
 	src/model/ListCurrentClientVersionRequest.cc
 	src/model/ListCurrentClientVersionResult.cc
 	src/model/ListCustomImagesRequest.cc
 	src/model/ListCustomImagesResult.cc
+	src/model/ListFileSystemWithMountTargetsRequest.cc
+	src/model/ListFileSystemWithMountTargetsResult.cc
 	src/model/ListImagesRequest.cc
 	src/model/ListImagesResult.cc
+	src/model/ListInstalledSoftwareRequest.cc
+	src/model/ListInstalledSoftwareResult.cc
+	src/model/ListInvocationResultsRequest.cc
+	src/model/ListInvocationResultsResult.cc
+	src/model/ListInvocationStatusRequest.cc
+	src/model/ListInvocationStatusResult.cc
 	src/model/ListJobTemplatesRequest.cc
 	src/model/ListJobTemplatesResult.cc
 	src/model/ListJobsRequest.cc
 	src/model/ListJobsResult.cc
+	src/model/ListJobsWithFiltersRequest.cc
+	src/model/ListJobsWithFiltersResult.cc
 	src/model/ListNodesRequest.cc
 	src/model/ListNodesResult.cc
+	src/model/ListNodesByQueueRequest.cc
+	src/model/ListNodesByQueueResult.cc
 	src/model/ListNodesNoPagingRequest.cc
 	src/model/ListNodesNoPagingResult.cc
 	src/model/ListPreferredEcsTypesRequest.cc
 	src/model/ListPreferredEcsTypesResult.cc
+	src/model/ListQueuesRequest.cc
+	src/model/ListQueuesResult.cc
 	src/model/ListRegionsRequest.cc
 	src/model/ListRegionsResult.cc
+	src/model/ListSecurityGroupsRequest.cc
+	src/model/ListSecurityGroupsResult.cc
 	src/model/ListSoftwaresRequest.cc
 	src/model/ListSoftwaresResult.cc
+	src/model/ListTagResourcesRequest.cc
+	src/model/ListTagResourcesResult.cc
+	src/model/ListTasksRequest.cc
+	src/model/ListTasksResult.cc
+	src/model/ListUpgradeClientsRequest.cc
+	src/model/ListUpgradeClientsResult.cc
 	src/model/ListUsersRequest.cc
 	src/model/ListUsersResult.cc
+	src/model/ListUsersAsyncRequest.cc
+	src/model/ListUsersAsyncResult.cc
 	src/model/ListVolumesRequest.cc
 	src/model/ListVolumesResult.cc
 	src/model/ModifyClusterAttributesRequest.cc
 	src/model/ModifyClusterAttributesResult.cc
+	src/model/ModifyContainerAppAttributesRequest.cc
+	src/model/ModifyContainerAppAttributesResult.cc
+	src/model/ModifyImageGatewayConfigRequest.cc
+	src/model/ModifyImageGatewayConfigResult.cc
 	src/model/ModifyUserGroupsRequest.cc
 	src/model/ModifyUserGroupsResult.cc
 	src/model/ModifyUserPasswordsRequest.cc
 	src/model/ModifyUserPasswordsResult.cc
+	src/model/ModifyVisualServicePasswdRequest.cc
+	src/model/ModifyVisualServicePasswdResult.cc
+	src/model/MountNFSRequest.cc
+	src/model/MountNFSResult.cc
+	src/model/PullImageRequest.cc
+	src/model/PullImageResult.cc
+	src/model/QueryServicePackAndPriceRequest.cc
+	src/model/QueryServicePackAndPriceResult.cc
+	src/model/RecoverClusterRequest.cc
+	src/model/RecoverClusterResult.cc
 	src/model/RerunJobsRequest.cc
 	src/model/RerunJobsResult.cc
 	src/model/ResetNodesRequest.cc
 	src/model/ResetNodesResult.cc
+	src/model/RunCloudMetricProfilingRequest.cc
+	src/model/RunCloudMetricProfilingResult.cc
 	src/model/SetAutoScaleConfigRequest.cc
 	src/model/SetAutoScaleConfigResult.cc
-	src/model/SetJobUserRequest.cc
-	src/model/SetJobUserResult.cc
+	src/model/SetGWSClusterPolicyRequest.cc
+	src/model/SetGWSClusterPolicyResult.cc
+	src/model/SetGWSInstanceNameRequest.cc
+	src/model/SetGWSInstanceNameResult.cc
+	src/model/SetGWSInstanceUserRequest.cc
+	src/model/SetGWSInstanceUserResult.cc
+	src/model/SetPostScriptsRequest.cc
+	src/model/SetPostScriptsResult.cc
+	src/model/SetQueueRequest.cc
+	src/model/SetQueueResult.cc
+	src/model/SetSchedulerInfoRequest.cc
+	src/model/SetSchedulerInfoResult.cc
+	src/model/StartClusterRequest.cc
+	src/model/StartClusterResult.cc
+	src/model/StartGWSInstanceRequest.cc
+	src/model/StartGWSInstanceResult.cc
+	src/model/StartNodesRequest.cc
+	src/model/StartNodesResult.cc
+	src/model/StartVisualServiceRequest.cc
+	src/model/StartVisualServiceResult.cc
+	src/model/StopClusterRequest.cc
+	src/model/StopClusterResult.cc
+	src/model/StopGWSInstanceRequest.cc
+	src/model/StopGWSInstanceResult.cc
 	src/model/StopJobsRequest.cc
 	src/model/StopJobsResult.cc
+	src/model/StopNodesRequest.cc
+	src/model/StopNodesResult.cc
+	src/model/StopVisualServiceRequest.cc
+	src/model/StopVisualServiceResult.cc
 	src/model/SubmitJobRequest.cc
 	src/model/SubmitJobResult.cc
+	src/model/SummaryImagesRequest.cc
+	src/model/SummaryImagesResult.cc
+	src/model/SummaryImagesInfoRequest.cc
+	src/model/SummaryImagesInfoResult.cc
+	src/model/SyncUsersRequest.cc
+	src/model/SyncUsersResult.cc
+	src/model/TagResourcesRequest.cc
+	src/model/TagResourcesResult.cc
+	src/model/UnTagResourcesRequest.cc
+	src/model/UnTagResourcesResult.cc
+	src/model/UninstallSoftwareRequest.cc
+	src/model/UninstallSoftwareResult.cc
+	src/model/UpdateClusterVolumesRequest.cc
+	src/model/UpdateClusterVolumesResult.cc
+	src/model/UpdateQueueConfigRequest.cc
+	src/model/UpdateQueueConfigResult.cc
 	src/model/UpgradeClientRequest.cc
 	src/model/UpgradeClientResult.cc )
 

ehpc/include/alibabacloud/ehpc/EHPCClient.h

@@ -22,76 +22,268 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "EHPCExport.h"
+#include "model/AddContainerAppRequest.h"
+#include "model/AddContainerAppResult.h"
+#include "model/AddExistedNodesRequest.h"
+#include "model/AddExistedNodesResult.h"
+#include "model/AddLocalNodesRequest.h"
+#include "model/AddLocalNodesResult.h"
 #include "model/AddNodesRequest.h"
 #include "model/AddNodesResult.h"
+#include "model/AddQueueRequest.h"
+#include "model/AddQueueResult.h"
+#include "model/AddSecurityGroupRequest.h"
+#include "model/AddSecurityGroupResult.h"
 #include "model/AddUsersRequest.h"
 #include "model/AddUsersResult.h"
+#include "model/ApplyNodesRequest.h"
+#include "model/ApplyNodesResult.h"
 #include "model/CreateClusterRequest.h"
 #include "model/CreateClusterResult.h"
+#include "model/CreateGWSClusterRequest.h"
+#include "model/CreateGWSClusterResult.h"
+#include "model/CreateGWSImageRequest.h"
+#include "model/CreateGWSImageResult.h"
+#include "model/CreateGWSInstanceRequest.h"
+#include "model/CreateGWSInstanceResult.h"
+#include "model/CreateHybridClusterRequest.h"
+#include "model/CreateHybridClusterResult.h"
+#include "model/CreateJobFileRequest.h"
+#include "model/CreateJobFileResult.h"
 #include "model/CreateJobTemplateRequest.h"
 #include "model/CreateJobTemplateResult.h"
 #include "model/DeleteClusterRequest.h"
 #include "model/DeleteClusterResult.h"
+#include "model/DeleteContainerAppsRequest.h"
+#include "model/DeleteContainerAppsResult.h"
+#include "model/DeleteGWSClusterRequest.h"
+#include "model/DeleteGWSClusterResult.h"
+#include "model/DeleteGWSInstanceRequest.h"
+#include "model/DeleteGWSInstanceResult.h"
+#include "model/DeleteImageRequest.h"
+#include "model/DeleteImageResult.h"
 #include "model/DeleteJobTemplatesRequest.h"
 #include "model/DeleteJobTemplatesResult.h"
 #include "model/DeleteJobsRequest.h"
 #include "model/DeleteJobsResult.h"
+#include "model/DeleteLocalImageRequest.h"
+#include "model/DeleteLocalImageResult.h"
 #include "model/DeleteNodesRequest.h"
 #include "model/DeleteNodesResult.h"
+#include "model/DeleteQueueRequest.h"
+#include "model/DeleteQueueResult.h"
+#include "model/DeleteSecurityGroupRequest.h"
+#include "model/DeleteSecurityGroupResult.h"
 #include "model/DeleteUsersRequest.h"
 #include "model/DeleteUsersResult.h"
+#include "model/DescribeAutoScaleConfigRequest.h"
+#include "model/DescribeAutoScaleConfigResult.h"
 #include "model/DescribeClusterRequest.h"
 #include "model/DescribeClusterResult.h"
+#include "model/DescribeContainerAppRequest.h"
+#include "model/DescribeContainerAppResult.h"
+#include "model/DescribeEstackImageRequest.h"
+#include "model/DescribeEstackImageResult.h"
+#include "model/DescribeGWSClusterPolicyRequest.h"
+#include "model/DescribeGWSClusterPolicyResult.h"
+#include "model/DescribeGWSClustersRequest.h"
+#include "model/DescribeGWSClustersResult.h"
+#include "model/DescribeGWSImagesRequest.h"
+#include "model/DescribeGWSImagesResult.h"
+#include "model/DescribeGWSInstancesRequest.h"
+#include "model/DescribeGWSInstancesResult.h"
+#include "model/DescribeImageRequest.h"
+#include "model/DescribeImageResult.h"
+#include "model/DescribeImageGatewayConfigRequest.h"
+#include "model/DescribeImageGatewayConfigResult.h"
+#include "model/DescribeImagePriceRequest.h"
+#include "model/DescribeImagePriceResult.h"
+#include "model/DescribeJobRequest.h"
+#include "model/DescribeJobResult.h"
+#include "model/DescribeNFSClientStatusRequest.h"
+#include "model/DescribeNFSClientStatusResult.h"
+#include "model/DescribePriceRequest.h"
+#include "model/DescribePriceResult.h"
 #include "model/EditJobTemplateRequest.h"
 #include "model/EditJobTemplateResult.h"
+#include "model/GetAccountingReportRequest.h"
+#include "model/GetAccountingReportResult.h"
 #include "model/GetAutoScaleConfigRequest.h"
 #include "model/GetAutoScaleConfigResult.h"
+#include "model/GetCloudMetricLogsRequest.h"
+#include "model/GetCloudMetricLogsResult.h"
+#include "model/GetCloudMetricProfilingRequest.h"
+#include "model/GetCloudMetricProfilingResult.h"
+#include "model/GetClusterVolumesRequest.h"
+#include "model/GetClusterVolumesResult.h"
+#include "model/GetCommonImageRequest.h"
+#include "model/GetCommonImageResult.h"
+#include "model/GetGWSConnectTicketRequest.h"
+#include "model/GetGWSConnectTicketResult.h"
+#include "model/GetHybridClusterConfigRequest.h"
+#include "model/GetHybridClusterConfigResult.h"
+#include "model/GetIfEcsTypeSupportHtConfigRequest.h"
+#include "model/GetIfEcsTypeSupportHtConfigResult.h"
+#include "model/GetPostScriptsRequest.h"
+#include "model/GetPostScriptsResult.h"
+#include "model/GetSchedulerInfoRequest.h"
+#include "model/GetSchedulerInfoResult.h"
+#include "model/GetUserImageRequest.h"
+#include "model/GetUserImageResult.h"
+#include "model/GetVisualServiceStatusRequest.h"
+#include "model/GetVisualServiceStatusResult.h"
+#include "model/InitializeEHPCRequest.h"
+#include "model/InitializeEHPCResult.h"
+#include "model/InspectImageRequest.h"
+#include "model/InspectImageResult.h"
+#include "model/InstallSoftwareRequest.h"
+#include "model/InstallSoftwareResult.h"
+#include "model/InvokeShellCommandRequest.h"
+#include "model/InvokeShellCommandResult.h"
+#include "model/ListAvailableEcsTypesRequest.h"
+#include "model/ListAvailableEcsTypesResult.h"
+#include "model/ListCloudMetricProfilingsRequest.h"
+#include "model/ListCloudMetricProfilingsResult.h"
 #include "model/ListClusterLogsRequest.h"
 #include "model/ListClusterLogsResult.h"
 #include "model/ListClustersRequest.h"
 #include "model/ListClustersResult.h"
+#include "model/ListClustersMetaRequest.h"
+#include "model/ListClustersMetaResult.h"
+#include "model/ListCommandsRequest.h"
+#include "model/ListCommandsResult.h"
+#include "model/ListCommunityImagesRequest.h"
+#include "model/ListCommunityImagesResult.h"
+#include "model/ListContainerAppsRequest.h"
+#include "model/ListContainerAppsResult.h"
+#include "model/ListContainerImagesRequest.h"
+#include "model/ListContainerImagesResult.h"
+#include "model/ListCpfsFileSystemsRequest.h"
+#include "model/ListCpfsFileSystemsResult.h"
 #include "model/ListCurrentClientVersionRequest.h"
 #include "model/ListCurrentClientVersionResult.h"
 #include "model/ListCustomImagesRequest.h"
 #include "model/ListCustomImagesResult.h"
+#include "model/ListFileSystemWithMountTargetsRequest.h"
+#include "model/ListFileSystemWithMountTargetsResult.h"
 #include "model/ListImagesRequest.h"
 #include "model/ListImagesResult.h"
+#include "model/ListInstalledSoftwareRequest.h"
+#include "model/ListInstalledSoftwareResult.h"
+#include "model/ListInvocationResultsRequest.h"
+#include "model/ListInvocationResultsResult.h"
+#include "model/ListInvocationStatusRequest.h"
+#include "model/ListInvocationStatusResult.h"
 #include "model/ListJobTemplatesRequest.h"
 #include "model/ListJobTemplatesResult.h"
 #include "model/ListJobsRequest.h"
 #include "model/ListJobsResult.h"
+#include "model/ListJobsWithFiltersRequest.h"
+#include "model/ListJobsWithFiltersResult.h"
 #include "model/ListNodesRequest.h"
 #include "model/ListNodesResult.h"
+#include "model/ListNodesByQueueRequest.h"
+#include "model/ListNodesByQueueResult.h"
 #include "model/ListNodesNoPagingRequest.h"
 #include "model/ListNodesNoPagingResult.h"
 #include "model/ListPreferredEcsTypesRequest.h"
 #include "model/ListPreferredEcsTypesResult.h"
+#include "model/ListQueuesRequest.h"
+#include "model/ListQueuesResult.h"
 #include "model/ListRegionsRequest.h"
 #include "model/ListRegionsResult.h"
+#include "model/ListSecurityGroupsRequest.h"
+#include "model/ListSecurityGroupsResult.h"
 #include "model/ListSoftwaresRequest.h"
 #include "model/ListSoftwaresResult.h"
+#include "model/ListTagResourcesRequest.h"
+#include "model/ListTagResourcesResult.h"
+#include "model/ListTasksRequest.h"
+#include "model/ListTasksResult.h"
+#include "model/ListUpgradeClientsRequest.h"
+#include "model/ListUpgradeClientsResult.h"
 #include "model/ListUsersRequest.h"
 #include "model/ListUsersResult.h"
+#include "model/ListUsersAsyncRequest.h"
+#include "model/ListUsersAsyncResult.h"
 #include "model/ListVolumesRequest.h"
 #include "model/ListVolumesResult.h"
 #include "model/ModifyClusterAttributesRequest.h"
 #include "model/ModifyClusterAttributesResult.h"
+#include "model/ModifyContainerAppAttributesRequest.h"
+#include "model/ModifyContainerAppAttributesResult.h"
+#include "model/ModifyImageGatewayConfigRequest.h"
+#include "model/ModifyImageGatewayConfigResult.h"
 #include "model/ModifyUserGroupsRequest.h"
 #include "model/ModifyUserGroupsResult.h"
 #include "model/ModifyUserPasswordsRequest.h"
 #include "model/ModifyUserPasswordsResult.h"
+#include "model/ModifyVisualServicePasswdRequest.h"
+#include "model/ModifyVisualServicePasswdResult.h"
+#include "model/MountNFSRequest.h"
+#include "model/MountNFSResult.h"
+#include "model/PullImageRequest.h"
+#include "model/PullImageResult.h"
+#include "model/QueryServicePackAndPriceRequest.h"
+#include "model/QueryServicePackAndPriceResult.h"
+#include "model/RecoverClusterRequest.h"
+#include "model/RecoverClusterResult.h"
 #include "model/RerunJobsRequest.h"
 #include "model/RerunJobsResult.h"
 #include "model/ResetNodesRequest.h"
 #include "model/ResetNodesResult.h"
+#include "model/RunCloudMetricProfilingRequest.h"
+#include "model/RunCloudMetricProfilingResult.h"
 #include "model/SetAutoScaleConfigRequest.h"
 #include "model/SetAutoScaleConfigResult.h"
-#include "model/SetJobUserRequest.h"
-#include "model/SetJobUserResult.h"
+#include "model/SetGWSClusterPolicyRequest.h"
+#include "model/SetGWSClusterPolicyResult.h"
+#include "model/SetGWSInstanceNameRequest.h"
+#include "model/SetGWSInstanceNameResult.h"
+#include "model/SetGWSInstanceUserRequest.h"
+#include "model/SetGWSInstanceUserResult.h"
+#include "model/SetPostScriptsRequest.h"
+#include "model/SetPostScriptsResult.h"
+#include "model/SetQueueRequest.h"
+#include "model/SetQueueResult.h"
+#include "model/SetSchedulerInfoRequest.h"
+#include "model/SetSchedulerInfoResult.h"
+#include "model/StartClusterRequest.h"
+#include "model/StartClusterResult.h"
+#include "model/StartGWSInstanceRequest.h"
+#include "model/StartGWSInstanceResult.h"
+#include "model/StartNodesRequest.h"
+#include "model/StartNodesResult.h"
+#include "model/StartVisualServiceRequest.h"
+#include "model/StartVisualServiceResult.h"
+#include "model/StopClusterRequest.h"
+#include "model/StopClusterResult.h"
+#include "model/StopGWSInstanceRequest.h"
+#include "model/StopGWSInstanceResult.h"
 #include "model/StopJobsRequest.h"
 #include "model/StopJobsResult.h"
+#include "model/StopNodesRequest.h"
+#include "model/StopNodesResult.h"
+#include "model/StopVisualServiceRequest.h"
+#include "model/StopVisualServiceResult.h"
 #include "model/SubmitJobRequest.h"
 #include "model/SubmitJobResult.h"
+#include "model/SummaryImagesRequest.h"
+#include "model/SummaryImagesResult.h"
+#include "model/SummaryImagesInfoRequest.h"
+#include "model/SummaryImagesInfoResult.h"
+#include "model/SyncUsersRequest.h"
+#include "model/SyncUsersResult.h"
+#include "model/TagResourcesRequest.h"
+#include "model/TagResourcesResult.h"
+#include "model/UnTagResourcesRequest.h"
+#include "model/UnTagResourcesResult.h"
+#include "model/UninstallSoftwareRequest.h"
+#include "model/UninstallSoftwareResult.h"
+#include "model/UpdateClusterVolumesRequest.h"
+#include "model/UpdateClusterVolumesResult.h"
+#include "model/UpdateQueueConfigRequest.h"
+#include "model/UpdateQueueConfigResult.h"
 #include "model/UpgradeClientRequest.h"
 #include "model/UpgradeClientResult.h"
 
@@ -103,111 +295,399 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_EHPC_EXPORT EHPCClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::AddContainerAppResult> AddContainerAppOutcome;
+			typedef std::future<AddContainerAppOutcome> AddContainerAppOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::AddContainerAppRequest&, const AddContainerAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddContainerAppAsyncHandler;
+			typedef Outcome<Error, Model::AddExistedNodesResult> AddExistedNodesOutcome;
+			typedef std::future<AddExistedNodesOutcome> AddExistedNodesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::AddExistedNodesRequest&, const AddExistedNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddExistedNodesAsyncHandler;
+			typedef Outcome<Error, Model::AddLocalNodesResult> AddLocalNodesOutcome;
+			typedef std::future<AddLocalNodesOutcome> AddLocalNodesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::AddLocalNodesRequest&, const AddLocalNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLocalNodesAsyncHandler;
 			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::AddQueueResult> AddQueueOutcome;
+			typedef std::future<AddQueueOutcome> AddQueueOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::AddQueueRequest&, const AddQueueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddQueueAsyncHandler;
+			typedef Outcome<Error, Model::AddSecurityGroupResult> AddSecurityGroupOutcome;
+			typedef std::future<AddSecurityGroupOutcome> AddSecurityGroupOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::AddSecurityGroupRequest&, const AddSecurityGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddSecurityGroupAsyncHandler;
 			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::ApplyNodesResult> ApplyNodesOutcome;
+			typedef std::future<ApplyNodesOutcome> ApplyNodesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ApplyNodesRequest&, const ApplyNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyNodesAsyncHandler;
 			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::CreateGWSClusterResult> CreateGWSClusterOutcome;
+			typedef std::future<CreateGWSClusterOutcome> CreateGWSClusterOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::CreateGWSClusterRequest&, const CreateGWSClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGWSClusterAsyncHandler;
+			typedef Outcome<Error, Model::CreateGWSImageResult> CreateGWSImageOutcome;
+			typedef std::future<CreateGWSImageOutcome> CreateGWSImageOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::CreateGWSImageRequest&, const CreateGWSImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGWSImageAsyncHandler;
+			typedef Outcome<Error, Model::CreateGWSInstanceResult> CreateGWSInstanceOutcome;
+			typedef std::future<CreateGWSInstanceOutcome> CreateGWSInstanceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::CreateGWSInstanceRequest&, const CreateGWSInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGWSInstanceAsyncHandler;
+			typedef Outcome<Error, Model::CreateHybridClusterResult> CreateHybridClusterOutcome;
+			typedef std::future<CreateHybridClusterOutcome> CreateHybridClusterOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::CreateHybridClusterRequest&, const CreateHybridClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateHybridClusterAsyncHandler;
+			typedef Outcome<Error, Model::CreateJobFileResult> CreateJobFileOutcome;
+			typedef std::future<CreateJobFileOutcome> CreateJobFileOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::CreateJobFileRequest&, const CreateJobFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateJobFileAsyncHandler;
 			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::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::DeleteContainerAppsResult> DeleteContainerAppsOutcome;
+			typedef std::future<DeleteContainerAppsOutcome> DeleteContainerAppsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DeleteContainerAppsRequest&, const DeleteContainerAppsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteContainerAppsAsyncHandler;
+			typedef Outcome<Error, Model::DeleteGWSClusterResult> DeleteGWSClusterOutcome;
+			typedef std::future<DeleteGWSClusterOutcome> DeleteGWSClusterOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DeleteGWSClusterRequest&, const DeleteGWSClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGWSClusterAsyncHandler;
+			typedef Outcome<Error, Model::DeleteGWSInstanceResult> DeleteGWSInstanceOutcome;
+			typedef std::future<DeleteGWSInstanceOutcome> DeleteGWSInstanceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DeleteGWSInstanceRequest&, const DeleteGWSInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGWSInstanceAsyncHandler;
+			typedef Outcome<Error, Model::DeleteImageResult> DeleteImageOutcome;
+			typedef std::future<DeleteImageOutcome> DeleteImageOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DeleteImageRequest&, const DeleteImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteImageAsyncHandler;
 			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::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::DeleteLocalImageResult> DeleteLocalImageOutcome;
+			typedef std::future<DeleteLocalImageOutcome> DeleteLocalImageOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DeleteLocalImageRequest&, const DeleteLocalImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLocalImageAsyncHandler;
 			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::DeleteQueueResult> DeleteQueueOutcome;
+			typedef std::future<DeleteQueueOutcome> DeleteQueueOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DeleteQueueRequest&, const DeleteQueueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteQueueAsyncHandler;
+			typedef Outcome<Error, Model::DeleteSecurityGroupResult> DeleteSecurityGroupOutcome;
+			typedef std::future<DeleteSecurityGroupOutcome> DeleteSecurityGroupOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DeleteSecurityGroupRequest&, const DeleteSecurityGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSecurityGroupAsyncHandler;
 			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::DescribeAutoScaleConfigResult> DescribeAutoScaleConfigOutcome;
+			typedef std::future<DescribeAutoScaleConfigOutcome> DescribeAutoScaleConfigOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeAutoScaleConfigRequest&, const DescribeAutoScaleConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAutoScaleConfigAsyncHandler;
 			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::DescribeContainerAppResult> DescribeContainerAppOutcome;
+			typedef std::future<DescribeContainerAppOutcome> DescribeContainerAppOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeContainerAppRequest&, const DescribeContainerAppOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeContainerAppAsyncHandler;
+			typedef Outcome<Error, Model::DescribeEstackImageResult> DescribeEstackImageOutcome;
+			typedef std::future<DescribeEstackImageOutcome> DescribeEstackImageOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeEstackImageRequest&, const DescribeEstackImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEstackImageAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGWSClusterPolicyResult> DescribeGWSClusterPolicyOutcome;
+			typedef std::future<DescribeGWSClusterPolicyOutcome> DescribeGWSClusterPolicyOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeGWSClusterPolicyRequest&, const DescribeGWSClusterPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGWSClusterPolicyAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGWSClustersResult> DescribeGWSClustersOutcome;
+			typedef std::future<DescribeGWSClustersOutcome> DescribeGWSClustersOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeGWSClustersRequest&, const DescribeGWSClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGWSClustersAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGWSImagesResult> DescribeGWSImagesOutcome;
+			typedef std::future<DescribeGWSImagesOutcome> DescribeGWSImagesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeGWSImagesRequest&, const DescribeGWSImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGWSImagesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGWSInstancesResult> DescribeGWSInstancesOutcome;
+			typedef std::future<DescribeGWSInstancesOutcome> DescribeGWSInstancesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeGWSInstancesRequest&, const DescribeGWSInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGWSInstancesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeImageResult> DescribeImageOutcome;
+			typedef std::future<DescribeImageOutcome> DescribeImageOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeImageRequest&, const DescribeImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImageAsyncHandler;
+			typedef Outcome<Error, Model::DescribeImageGatewayConfigResult> DescribeImageGatewayConfigOutcome;
+			typedef std::future<DescribeImageGatewayConfigOutcome> DescribeImageGatewayConfigOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeImageGatewayConfigRequest&, const DescribeImageGatewayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImageGatewayConfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeImagePriceResult> DescribeImagePriceOutcome;
+			typedef std::future<DescribeImagePriceOutcome> DescribeImagePriceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeImagePriceRequest&, const DescribeImagePriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImagePriceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeJobResult> DescribeJobOutcome;
+			typedef std::future<DescribeJobOutcome> DescribeJobOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeJobRequest&, const DescribeJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeJobAsyncHandler;
+			typedef Outcome<Error, Model::DescribeNFSClientStatusResult> DescribeNFSClientStatusOutcome;
+			typedef std::future<DescribeNFSClientStatusOutcome> DescribeNFSClientStatusOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribeNFSClientStatusRequest&, const DescribeNFSClientStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNFSClientStatusAsyncHandler;
+			typedef Outcome<Error, Model::DescribePriceResult> DescribePriceOutcome;
+			typedef std::future<DescribePriceOutcome> DescribePriceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::DescribePriceRequest&, const DescribePriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePriceAsyncHandler;
 			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::GetAccountingReportResult> GetAccountingReportOutcome;
+			typedef std::future<GetAccountingReportOutcome> GetAccountingReportOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetAccountingReportRequest&, const GetAccountingReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAccountingReportAsyncHandler;
 			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::GetCloudMetricLogsResult> GetCloudMetricLogsOutcome;
+			typedef std::future<GetCloudMetricLogsOutcome> GetCloudMetricLogsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetCloudMetricLogsRequest&, const GetCloudMetricLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCloudMetricLogsAsyncHandler;
+			typedef Outcome<Error, Model::GetCloudMetricProfilingResult> GetCloudMetricProfilingOutcome;
+			typedef std::future<GetCloudMetricProfilingOutcome> GetCloudMetricProfilingOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetCloudMetricProfilingRequest&, const GetCloudMetricProfilingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCloudMetricProfilingAsyncHandler;
+			typedef Outcome<Error, Model::GetClusterVolumesResult> GetClusterVolumesOutcome;
+			typedef std::future<GetClusterVolumesOutcome> GetClusterVolumesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetClusterVolumesRequest&, const GetClusterVolumesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetClusterVolumesAsyncHandler;
+			typedef Outcome<Error, Model::GetCommonImageResult> GetCommonImageOutcome;
+			typedef std::future<GetCommonImageOutcome> GetCommonImageOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetCommonImageRequest&, const GetCommonImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCommonImageAsyncHandler;
+			typedef Outcome<Error, Model::GetGWSConnectTicketResult> GetGWSConnectTicketOutcome;
+			typedef std::future<GetGWSConnectTicketOutcome> GetGWSConnectTicketOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetGWSConnectTicketRequest&, const GetGWSConnectTicketOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetGWSConnectTicketAsyncHandler;
+			typedef Outcome<Error, Model::GetHybridClusterConfigResult> GetHybridClusterConfigOutcome;
+			typedef std::future<GetHybridClusterConfigOutcome> GetHybridClusterConfigOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetHybridClusterConfigRequest&, const GetHybridClusterConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetHybridClusterConfigAsyncHandler;
+			typedef Outcome<Error, Model::GetIfEcsTypeSupportHtConfigResult> GetIfEcsTypeSupportHtConfigOutcome;
+			typedef std::future<GetIfEcsTypeSupportHtConfigOutcome> GetIfEcsTypeSupportHtConfigOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetIfEcsTypeSupportHtConfigRequest&, const GetIfEcsTypeSupportHtConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetIfEcsTypeSupportHtConfigAsyncHandler;
+			typedef Outcome<Error, Model::GetPostScriptsResult> GetPostScriptsOutcome;
+			typedef std::future<GetPostScriptsOutcome> GetPostScriptsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetPostScriptsRequest&, const GetPostScriptsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPostScriptsAsyncHandler;
+			typedef Outcome<Error, Model::GetSchedulerInfoResult> GetSchedulerInfoOutcome;
+			typedef std::future<GetSchedulerInfoOutcome> GetSchedulerInfoOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetSchedulerInfoRequest&, const GetSchedulerInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSchedulerInfoAsyncHandler;
+			typedef Outcome<Error, Model::GetUserImageResult> GetUserImageOutcome;
+			typedef std::future<GetUserImageOutcome> GetUserImageOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetUserImageRequest&, const GetUserImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetUserImageAsyncHandler;
+			typedef Outcome<Error, Model::GetVisualServiceStatusResult> GetVisualServiceStatusOutcome;
+			typedef std::future<GetVisualServiceStatusOutcome> GetVisualServiceStatusOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::GetVisualServiceStatusRequest&, const GetVisualServiceStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVisualServiceStatusAsyncHandler;
+			typedef Outcome<Error, Model::InitializeEHPCResult> InitializeEHPCOutcome;
+			typedef std::future<InitializeEHPCOutcome> InitializeEHPCOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::InitializeEHPCRequest&, const InitializeEHPCOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InitializeEHPCAsyncHandler;
+			typedef Outcome<Error, Model::InspectImageResult> InspectImageOutcome;
+			typedef std::future<InspectImageOutcome> InspectImageOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::InspectImageRequest&, const InspectImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InspectImageAsyncHandler;
+			typedef Outcome<Error, Model::InstallSoftwareResult> InstallSoftwareOutcome;
+			typedef std::future<InstallSoftwareOutcome> InstallSoftwareOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::InstallSoftwareRequest&, const InstallSoftwareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InstallSoftwareAsyncHandler;
+			typedef Outcome<Error, Model::InvokeShellCommandResult> InvokeShellCommandOutcome;
+			typedef std::future<InvokeShellCommandOutcome> InvokeShellCommandOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::InvokeShellCommandRequest&, const InvokeShellCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> InvokeShellCommandAsyncHandler;
+			typedef Outcome<Error, Model::ListAvailableEcsTypesResult> ListAvailableEcsTypesOutcome;
+			typedef std::future<ListAvailableEcsTypesOutcome> ListAvailableEcsTypesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListAvailableEcsTypesRequest&, const ListAvailableEcsTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAvailableEcsTypesAsyncHandler;
+			typedef Outcome<Error, Model::ListCloudMetricProfilingsResult> ListCloudMetricProfilingsOutcome;
+			typedef std::future<ListCloudMetricProfilingsOutcome> ListCloudMetricProfilingsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListCloudMetricProfilingsRequest&, const ListCloudMetricProfilingsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCloudMetricProfilingsAsyncHandler;
 			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::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::ListClustersMetaResult> ListClustersMetaOutcome;
+			typedef std::future<ListClustersMetaOutcome> ListClustersMetaOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListClustersMetaRequest&, const ListClustersMetaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListClustersMetaAsyncHandler;
+			typedef Outcome<Error, Model::ListCommandsResult> ListCommandsOutcome;
+			typedef std::future<ListCommandsOutcome> ListCommandsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListCommandsRequest&, const ListCommandsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCommandsAsyncHandler;
+			typedef Outcome<Error, Model::ListCommunityImagesResult> ListCommunityImagesOutcome;
+			typedef std::future<ListCommunityImagesOutcome> ListCommunityImagesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListCommunityImagesRequest&, const ListCommunityImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCommunityImagesAsyncHandler;
+			typedef Outcome<Error, Model::ListContainerAppsResult> ListContainerAppsOutcome;
+			typedef std::future<ListContainerAppsOutcome> ListContainerAppsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListContainerAppsRequest&, const ListContainerAppsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListContainerAppsAsyncHandler;
+			typedef Outcome<Error, Model::ListContainerImagesResult> ListContainerImagesOutcome;
+			typedef std::future<ListContainerImagesOutcome> ListContainerImagesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListContainerImagesRequest&, const ListContainerImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListContainerImagesAsyncHandler;
+			typedef Outcome<Error, Model::ListCpfsFileSystemsResult> ListCpfsFileSystemsOutcome;
+			typedef std::future<ListCpfsFileSystemsOutcome> ListCpfsFileSystemsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListCpfsFileSystemsRequest&, const ListCpfsFileSystemsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCpfsFileSystemsAsyncHandler;
 			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::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::ListFileSystemWithMountTargetsResult> ListFileSystemWithMountTargetsOutcome;
+			typedef std::future<ListFileSystemWithMountTargetsOutcome> ListFileSystemWithMountTargetsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListFileSystemWithMountTargetsRequest&, const ListFileSystemWithMountTargetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFileSystemWithMountTargetsAsyncHandler;
 			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::ListInstalledSoftwareResult> ListInstalledSoftwareOutcome;
+			typedef std::future<ListInstalledSoftwareOutcome> ListInstalledSoftwareOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListInstalledSoftwareRequest&, const ListInstalledSoftwareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstalledSoftwareAsyncHandler;
+			typedef Outcome<Error, Model::ListInvocationResultsResult> ListInvocationResultsOutcome;
+			typedef std::future<ListInvocationResultsOutcome> ListInvocationResultsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListInvocationResultsRequest&, const ListInvocationResultsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInvocationResultsAsyncHandler;
+			typedef Outcome<Error, Model::ListInvocationStatusResult> ListInvocationStatusOutcome;
+			typedef std::future<ListInvocationStatusOutcome> ListInvocationStatusOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListInvocationStatusRequest&, const ListInvocationStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInvocationStatusAsyncHandler;
 			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::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::ListJobsWithFiltersResult> ListJobsWithFiltersOutcome;
+			typedef std::future<ListJobsWithFiltersOutcome> ListJobsWithFiltersOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListJobsWithFiltersRequest&, const ListJobsWithFiltersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListJobsWithFiltersAsyncHandler;
 			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::ListNodesByQueueResult> ListNodesByQueueOutcome;
+			typedef std::future<ListNodesByQueueOutcome> ListNodesByQueueOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListNodesByQueueRequest&, const ListNodesByQueueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListNodesByQueueAsyncHandler;
 			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::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::ListQueuesResult> ListQueuesOutcome;
+			typedef std::future<ListQueuesOutcome> ListQueuesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListQueuesRequest&, const ListQueuesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListQueuesAsyncHandler;
 			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::ListSecurityGroupsResult> ListSecurityGroupsOutcome;
+			typedef std::future<ListSecurityGroupsOutcome> ListSecurityGroupsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListSecurityGroupsRequest&, const ListSecurityGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListSecurityGroupsAsyncHandler;
 			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::ListTagResourcesResult> ListTagResourcesOutcome;
+			typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::ListTasksResult> ListTasksOutcome;
+			typedef std::future<ListTasksOutcome> ListTasksOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListTasksRequest&, const ListTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTasksAsyncHandler;
+			typedef Outcome<Error, Model::ListUpgradeClientsResult> ListUpgradeClientsOutcome;
+			typedef std::future<ListUpgradeClientsOutcome> ListUpgradeClientsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListUpgradeClientsRequest&, const ListUpgradeClientsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUpgradeClientsAsyncHandler;
 			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::ListUsersAsyncResult> ListUsersAsyncOutcome;
+			typedef std::future<ListUsersAsyncOutcome> ListUsersAsyncOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ListUsersAsyncRequest&, const ListUsersAsyncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUsersAsyncAsyncHandler;
 			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::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::ModifyContainerAppAttributesResult> ModifyContainerAppAttributesOutcome;
+			typedef std::future<ModifyContainerAppAttributesOutcome> ModifyContainerAppAttributesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ModifyContainerAppAttributesRequest&, const ModifyContainerAppAttributesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyContainerAppAttributesAsyncHandler;
+			typedef Outcome<Error, Model::ModifyImageGatewayConfigResult> ModifyImageGatewayConfigOutcome;
+			typedef std::future<ModifyImageGatewayConfigOutcome> ModifyImageGatewayConfigOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ModifyImageGatewayConfigRequest&, const ModifyImageGatewayConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyImageGatewayConfigAsyncHandler;
 			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::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;
+			typedef Outcome<Error, Model::ModifyVisualServicePasswdResult> ModifyVisualServicePasswdOutcome;
+			typedef std::future<ModifyVisualServicePasswdOutcome> ModifyVisualServicePasswdOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::ModifyVisualServicePasswdRequest&, const ModifyVisualServicePasswdOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyVisualServicePasswdAsyncHandler;
+			typedef Outcome<Error, Model::MountNFSResult> MountNFSOutcome;
+			typedef std::future<MountNFSOutcome> MountNFSOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::MountNFSRequest&, const MountNFSOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MountNFSAsyncHandler;
+			typedef Outcome<Error, Model::PullImageResult> PullImageOutcome;
+			typedef std::future<PullImageOutcome> PullImageOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::PullImageRequest&, const PullImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PullImageAsyncHandler;
+			typedef Outcome<Error, Model::QueryServicePackAndPriceResult> QueryServicePackAndPriceOutcome;
+			typedef std::future<QueryServicePackAndPriceOutcome> QueryServicePackAndPriceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::QueryServicePackAndPriceRequest&, const QueryServicePackAndPriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> QueryServicePackAndPriceAsyncHandler;
+			typedef Outcome<Error, Model::RecoverClusterResult> RecoverClusterOutcome;
+			typedef std::future<RecoverClusterOutcome> RecoverClusterOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::RecoverClusterRequest&, const RecoverClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecoverClusterAsyncHandler;
 			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::RunCloudMetricProfilingResult> RunCloudMetricProfilingOutcome;
+			typedef std::future<RunCloudMetricProfilingOutcome> RunCloudMetricProfilingOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::RunCloudMetricProfilingRequest&, const RunCloudMetricProfilingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunCloudMetricProfilingAsyncHandler;
 			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::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::SetGWSClusterPolicyResult> SetGWSClusterPolicyOutcome;
+			typedef std::future<SetGWSClusterPolicyOutcome> SetGWSClusterPolicyOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SetGWSClusterPolicyRequest&, const SetGWSClusterPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGWSClusterPolicyAsyncHandler;
+			typedef Outcome<Error, Model::SetGWSInstanceNameResult> SetGWSInstanceNameOutcome;
+			typedef std::future<SetGWSInstanceNameOutcome> SetGWSInstanceNameOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SetGWSInstanceNameRequest&, const SetGWSInstanceNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGWSInstanceNameAsyncHandler;
+			typedef Outcome<Error, Model::SetGWSInstanceUserResult> SetGWSInstanceUserOutcome;
+			typedef std::future<SetGWSInstanceUserOutcome> SetGWSInstanceUserOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SetGWSInstanceUserRequest&, const SetGWSInstanceUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetGWSInstanceUserAsyncHandler;
+			typedef Outcome<Error, Model::SetPostScriptsResult> SetPostScriptsOutcome;
+			typedef std::future<SetPostScriptsOutcome> SetPostScriptsOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SetPostScriptsRequest&, const SetPostScriptsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetPostScriptsAsyncHandler;
+			typedef Outcome<Error, Model::SetQueueResult> SetQueueOutcome;
+			typedef std::future<SetQueueOutcome> SetQueueOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SetQueueRequest&, const SetQueueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetQueueAsyncHandler;
+			typedef Outcome<Error, Model::SetSchedulerInfoResult> SetSchedulerInfoOutcome;
+			typedef std::future<SetSchedulerInfoOutcome> SetSchedulerInfoOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SetSchedulerInfoRequest&, const SetSchedulerInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetSchedulerInfoAsyncHandler;
+			typedef Outcome<Error, Model::StartClusterResult> StartClusterOutcome;
+			typedef std::future<StartClusterOutcome> StartClusterOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::StartClusterRequest&, const StartClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartClusterAsyncHandler;
+			typedef Outcome<Error, Model::StartGWSInstanceResult> StartGWSInstanceOutcome;
+			typedef std::future<StartGWSInstanceOutcome> StartGWSInstanceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::StartGWSInstanceRequest&, const StartGWSInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartGWSInstanceAsyncHandler;
+			typedef Outcome<Error, Model::StartNodesResult> StartNodesOutcome;
+			typedef std::future<StartNodesOutcome> StartNodesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::StartNodesRequest&, const StartNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartNodesAsyncHandler;
+			typedef Outcome<Error, Model::StartVisualServiceResult> StartVisualServiceOutcome;
+			typedef std::future<StartVisualServiceOutcome> StartVisualServiceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::StartVisualServiceRequest&, const StartVisualServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartVisualServiceAsyncHandler;
+			typedef Outcome<Error, Model::StopClusterResult> StopClusterOutcome;
+			typedef std::future<StopClusterOutcome> StopClusterOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::StopClusterRequest&, const StopClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopClusterAsyncHandler;
+			typedef Outcome<Error, Model::StopGWSInstanceResult> StopGWSInstanceOutcome;
+			typedef std::future<StopGWSInstanceOutcome> StopGWSInstanceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::StopGWSInstanceRequest&, const StopGWSInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopGWSInstanceAsyncHandler;
 			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::StopNodesResult> StopNodesOutcome;
+			typedef std::future<StopNodesOutcome> StopNodesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::StopNodesRequest&, const StopNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopNodesAsyncHandler;
+			typedef Outcome<Error, Model::StopVisualServiceResult> StopVisualServiceOutcome;
+			typedef std::future<StopVisualServiceOutcome> StopVisualServiceOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::StopVisualServiceRequest&, const StopVisualServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopVisualServiceAsyncHandler;
 			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::SummaryImagesResult> SummaryImagesOutcome;
+			typedef std::future<SummaryImagesOutcome> SummaryImagesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SummaryImagesRequest&, const SummaryImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SummaryImagesAsyncHandler;
+			typedef Outcome<Error, Model::SummaryImagesInfoResult> SummaryImagesInfoOutcome;
+			typedef std::future<SummaryImagesInfoOutcome> SummaryImagesInfoOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SummaryImagesInfoRequest&, const SummaryImagesInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SummaryImagesInfoAsyncHandler;
+			typedef Outcome<Error, Model::SyncUsersResult> SyncUsersOutcome;
+			typedef std::future<SyncUsersOutcome> SyncUsersOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::SyncUsersRequest&, const SyncUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SyncUsersAsyncHandler;
+			typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
+			typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::UnTagResourcesResult> UnTagResourcesOutcome;
+			typedef std::future<UnTagResourcesOutcome> UnTagResourcesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::UnTagResourcesRequest&, const UnTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnTagResourcesAsyncHandler;
+			typedef Outcome<Error, Model::UninstallSoftwareResult> UninstallSoftwareOutcome;
+			typedef std::future<UninstallSoftwareOutcome> UninstallSoftwareOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::UninstallSoftwareRequest&, const UninstallSoftwareOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UninstallSoftwareAsyncHandler;
+			typedef Outcome<Error, Model::UpdateClusterVolumesResult> UpdateClusterVolumesOutcome;
+			typedef std::future<UpdateClusterVolumesOutcome> UpdateClusterVolumesOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::UpdateClusterVolumesRequest&, const UpdateClusterVolumesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateClusterVolumesAsyncHandler;
+			typedef Outcome<Error, Model::UpdateQueueConfigResult> UpdateQueueConfigOutcome;
+			typedef std::future<UpdateQueueConfigOutcome> UpdateQueueConfigOutcomeCallable;
+			typedef std::function<void(const EHPCClient*, const Model::UpdateQueueConfigRequest&, const UpdateQueueConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateQueueConfigAsyncHandler;
 			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;
@@ -216,111 +696,399 @@ namespace AlibabaCloud
 			EHPCClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			EHPCClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~EHPCClient();
+			AddContainerAppOutcome addContainerApp(const Model::AddContainerAppRequest &request)const;
+			void addContainerAppAsync(const Model::AddContainerAppRequest& request, const AddContainerAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddContainerAppOutcomeCallable addContainerAppCallable(const Model::AddContainerAppRequest& request) const;
+			AddExistedNodesOutcome addExistedNodes(const Model::AddExistedNodesRequest &request)const;
+			void addExistedNodesAsync(const Model::AddExistedNodesRequest& request, const AddExistedNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddExistedNodesOutcomeCallable addExistedNodesCallable(const Model::AddExistedNodesRequest& request) const;
+			AddLocalNodesOutcome addLocalNodes(const Model::AddLocalNodesRequest &request)const;
+			void addLocalNodesAsync(const Model::AddLocalNodesRequest& request, const AddLocalNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddLocalNodesOutcomeCallable addLocalNodesCallable(const Model::AddLocalNodesRequest& 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;
+			AddQueueOutcome addQueue(const Model::AddQueueRequest &request)const;
+			void addQueueAsync(const Model::AddQueueRequest& request, const AddQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddQueueOutcomeCallable addQueueCallable(const Model::AddQueueRequest& request) const;
+			AddSecurityGroupOutcome addSecurityGroup(const Model::AddSecurityGroupRequest &request)const;
+			void addSecurityGroupAsync(const Model::AddSecurityGroupRequest& request, const AddSecurityGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddSecurityGroupOutcomeCallable addSecurityGroupCallable(const Model::AddSecurityGroupRequest& 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;
+			ApplyNodesOutcome applyNodes(const Model::ApplyNodesRequest &request)const;
+			void applyNodesAsync(const Model::ApplyNodesRequest& request, const ApplyNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ApplyNodesOutcomeCallable applyNodesCallable(const Model::ApplyNodesRequest& 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;
+			CreateGWSClusterOutcome createGWSCluster(const Model::CreateGWSClusterRequest &request)const;
+			void createGWSClusterAsync(const Model::CreateGWSClusterRequest& request, const CreateGWSClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGWSClusterOutcomeCallable createGWSClusterCallable(const Model::CreateGWSClusterRequest& request) const;
+			CreateGWSImageOutcome createGWSImage(const Model::CreateGWSImageRequest &request)const;
+			void createGWSImageAsync(const Model::CreateGWSImageRequest& request, const CreateGWSImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGWSImageOutcomeCallable createGWSImageCallable(const Model::CreateGWSImageRequest& request) const;
+			CreateGWSInstanceOutcome createGWSInstance(const Model::CreateGWSInstanceRequest &request)const;
+			void createGWSInstanceAsync(const Model::CreateGWSInstanceRequest& request, const CreateGWSInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateGWSInstanceOutcomeCallable createGWSInstanceCallable(const Model::CreateGWSInstanceRequest& request) const;
+			CreateHybridClusterOutcome createHybridCluster(const Model::CreateHybridClusterRequest &request)const;
+			void createHybridClusterAsync(const Model::CreateHybridClusterRequest& request, const CreateHybridClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateHybridClusterOutcomeCallable createHybridClusterCallable(const Model::CreateHybridClusterRequest& request) const;
+			CreateJobFileOutcome createJobFile(const Model::CreateJobFileRequest &request)const;
+			void createJobFileAsync(const Model::CreateJobFileRequest& request, const CreateJobFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateJobFileOutcomeCallable createJobFileCallable(const Model::CreateJobFileRequest& 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;
 			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;
+			DeleteContainerAppsOutcome deleteContainerApps(const Model::DeleteContainerAppsRequest &request)const;
+			void deleteContainerAppsAsync(const Model::DeleteContainerAppsRequest& request, const DeleteContainerAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteContainerAppsOutcomeCallable deleteContainerAppsCallable(const Model::DeleteContainerAppsRequest& request) const;
+			DeleteGWSClusterOutcome deleteGWSCluster(const Model::DeleteGWSClusterRequest &request)const;
+			void deleteGWSClusterAsync(const Model::DeleteGWSClusterRequest& request, const DeleteGWSClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGWSClusterOutcomeCallable deleteGWSClusterCallable(const Model::DeleteGWSClusterRequest& request) const;
+			DeleteGWSInstanceOutcome deleteGWSInstance(const Model::DeleteGWSInstanceRequest &request)const;
+			void deleteGWSInstanceAsync(const Model::DeleteGWSInstanceRequest& request, const DeleteGWSInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteGWSInstanceOutcomeCallable deleteGWSInstanceCallable(const Model::DeleteGWSInstanceRequest& request) const;
+			DeleteImageOutcome deleteImage(const Model::DeleteImageRequest &request)const;
+			void deleteImageAsync(const Model::DeleteImageRequest& request, const DeleteImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteImageOutcomeCallable deleteImageCallable(const Model::DeleteImageRequest& 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;
 			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;
+			DeleteLocalImageOutcome deleteLocalImage(const Model::DeleteLocalImageRequest &request)const;
+			void deleteLocalImageAsync(const Model::DeleteLocalImageRequest& request, const DeleteLocalImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteLocalImageOutcomeCallable deleteLocalImageCallable(const Model::DeleteLocalImageRequest& 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;
+			DeleteQueueOutcome deleteQueue(const Model::DeleteQueueRequest &request)const;
+			void deleteQueueAsync(const Model::DeleteQueueRequest& request, const DeleteQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteQueueOutcomeCallable deleteQueueCallable(const Model::DeleteQueueRequest& request) const;
+			DeleteSecurityGroupOutcome deleteSecurityGroup(const Model::DeleteSecurityGroupRequest &request)const;
+			void deleteSecurityGroupAsync(const Model::DeleteSecurityGroupRequest& request, const DeleteSecurityGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteSecurityGroupOutcomeCallable deleteSecurityGroupCallable(const Model::DeleteSecurityGroupRequest& request) const;
 			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;
+			DescribeAutoScaleConfigOutcome describeAutoScaleConfig(const Model::DescribeAutoScaleConfigRequest &request)const;
+			void describeAutoScaleConfigAsync(const Model::DescribeAutoScaleConfigRequest& request, const DescribeAutoScaleConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAutoScaleConfigOutcomeCallable describeAutoScaleConfigCallable(const Model::DescribeAutoScaleConfigRequest& 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;
+			DescribeContainerAppOutcome describeContainerApp(const Model::DescribeContainerAppRequest &request)const;
+			void describeContainerAppAsync(const Model::DescribeContainerAppRequest& request, const DescribeContainerAppAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeContainerAppOutcomeCallable describeContainerAppCallable(const Model::DescribeContainerAppRequest& request) const;
+			DescribeEstackImageOutcome describeEstackImage(const Model::DescribeEstackImageRequest &request)const;
+			void describeEstackImageAsync(const Model::DescribeEstackImageRequest& request, const DescribeEstackImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeEstackImageOutcomeCallable describeEstackImageCallable(const Model::DescribeEstackImageRequest& request) const;
+			DescribeGWSClusterPolicyOutcome describeGWSClusterPolicy(const Model::DescribeGWSClusterPolicyRequest &request)const;
+			void describeGWSClusterPolicyAsync(const Model::DescribeGWSClusterPolicyRequest& request, const DescribeGWSClusterPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGWSClusterPolicyOutcomeCallable describeGWSClusterPolicyCallable(const Model::DescribeGWSClusterPolicyRequest& request) const;
+			DescribeGWSClustersOutcome describeGWSClusters(const Model::DescribeGWSClustersRequest &request)const;
+			void describeGWSClustersAsync(const Model::DescribeGWSClustersRequest& request, const DescribeGWSClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGWSClustersOutcomeCallable describeGWSClustersCallable(const Model::DescribeGWSClustersRequest& request) const;
+			DescribeGWSImagesOutcome describeGWSImages(const Model::DescribeGWSImagesRequest &request)const;
+			void describeGWSImagesAsync(const Model::DescribeGWSImagesRequest& request, const DescribeGWSImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGWSImagesOutcomeCallable describeGWSImagesCallable(const Model::DescribeGWSImagesRequest& request) const;
+			DescribeGWSInstancesOutcome describeGWSInstances(const Model::DescribeGWSInstancesRequest &request)const;
+			void describeGWSInstancesAsync(const Model::DescribeGWSInstancesRequest& request, const DescribeGWSInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGWSInstancesOutcomeCallable describeGWSInstancesCallable(const Model::DescribeGWSInstancesRequest& request) const;
+			DescribeImageOutcome describeImage(const Model::DescribeImageRequest &request)const;
+			void describeImageAsync(const Model::DescribeImageRequest& request, const DescribeImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeImageOutcomeCallable describeImageCallable(const Model::DescribeImageRequest& request) const;
+			DescribeImageGatewayConfigOutcome describeImageGatewayConfig(const Model::DescribeImageGatewayConfigRequest &request)const;
+			void describeImageGatewayConfigAsync(const Model::DescribeImageGatewayConfigRequest& request, const DescribeImageGatewayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeImageGatewayConfigOutcomeCallable describeImageGatewayConfigCallable(const Model::DescribeImageGatewayConfigRequest& request) const;
+			DescribeImagePriceOutcome describeImagePrice(const Model::DescribeImagePriceRequest &request)const;
+			void describeImagePriceAsync(const Model::DescribeImagePriceRequest& request, const DescribeImagePriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeImagePriceOutcomeCallable describeImagePriceCallable(const Model::DescribeImagePriceRequest& request) const;
+			DescribeJobOutcome describeJob(const Model::DescribeJobRequest &request)const;
+			void describeJobAsync(const Model::DescribeJobRequest& request, const DescribeJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeJobOutcomeCallable describeJobCallable(const Model::DescribeJobRequest& request) const;
+			DescribeNFSClientStatusOutcome describeNFSClientStatus(const Model::DescribeNFSClientStatusRequest &request)const;
+			void describeNFSClientStatusAsync(const Model::DescribeNFSClientStatusRequest& request, const DescribeNFSClientStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeNFSClientStatusOutcomeCallable describeNFSClientStatusCallable(const Model::DescribeNFSClientStatusRequest& request) const;
+			DescribePriceOutcome describePrice(const Model::DescribePriceRequest &request)const;
+			void describePriceAsync(const Model::DescribePriceRequest& request, const DescribePriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribePriceOutcomeCallable describePriceCallable(const Model::DescribePriceRequest& 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;
+			GetAccountingReportOutcome getAccountingReport(const Model::GetAccountingReportRequest &request)const;
+			void getAccountingReportAsync(const Model::GetAccountingReportRequest& request, const GetAccountingReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAccountingReportOutcomeCallable getAccountingReportCallable(const Model::GetAccountingReportRequest& 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;
+			GetCloudMetricLogsOutcome getCloudMetricLogs(const Model::GetCloudMetricLogsRequest &request)const;
+			void getCloudMetricLogsAsync(const Model::GetCloudMetricLogsRequest& request, const GetCloudMetricLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetCloudMetricLogsOutcomeCallable getCloudMetricLogsCallable(const Model::GetCloudMetricLogsRequest& request) const;
+			GetCloudMetricProfilingOutcome getCloudMetricProfiling(const Model::GetCloudMetricProfilingRequest &request)const;
+			void getCloudMetricProfilingAsync(const Model::GetCloudMetricProfilingRequest& request, const GetCloudMetricProfilingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetCloudMetricProfilingOutcomeCallable getCloudMetricProfilingCallable(const Model::GetCloudMetricProfilingRequest& request) const;
+			GetClusterVolumesOutcome getClusterVolumes(const Model::GetClusterVolumesRequest &request)const;
+			void getClusterVolumesAsync(const Model::GetClusterVolumesRequest& request, const GetClusterVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetClusterVolumesOutcomeCallable getClusterVolumesCallable(const Model::GetClusterVolumesRequest& request) const;
+			GetCommonImageOutcome getCommonImage(const Model::GetCommonImageRequest &request)const;
+			void getCommonImageAsync(const Model::GetCommonImageRequest& request, const GetCommonImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetCommonImageOutcomeCallable getCommonImageCallable(const Model::GetCommonImageRequest& request) const;
+			GetGWSConnectTicketOutcome getGWSConnectTicket(const Model::GetGWSConnectTicketRequest &request)const;
+			void getGWSConnectTicketAsync(const Model::GetGWSConnectTicketRequest& request, const GetGWSConnectTicketAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetGWSConnectTicketOutcomeCallable getGWSConnectTicketCallable(const Model::GetGWSConnectTicketRequest& request) const;
+			GetHybridClusterConfigOutcome getHybridClusterConfig(const Model::GetHybridClusterConfigRequest &request)const;
+			void getHybridClusterConfigAsync(const Model::GetHybridClusterConfigRequest& request, const GetHybridClusterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetHybridClusterConfigOutcomeCallable getHybridClusterConfigCallable(const Model::GetHybridClusterConfigRequest& request) const;
+			GetIfEcsTypeSupportHtConfigOutcome getIfEcsTypeSupportHtConfig(const Model::GetIfEcsTypeSupportHtConfigRequest &request)const;
+			void getIfEcsTypeSupportHtConfigAsync(const Model::GetIfEcsTypeSupportHtConfigRequest& request, const GetIfEcsTypeSupportHtConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetIfEcsTypeSupportHtConfigOutcomeCallable getIfEcsTypeSupportHtConfigCallable(const Model::GetIfEcsTypeSupportHtConfigRequest& request) const;
+			GetPostScriptsOutcome getPostScripts(const Model::GetPostScriptsRequest &request)const;
+			void getPostScriptsAsync(const Model::GetPostScriptsRequest& request, const GetPostScriptsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetPostScriptsOutcomeCallable getPostScriptsCallable(const Model::GetPostScriptsRequest& request) const;
+			GetSchedulerInfoOutcome getSchedulerInfo(const Model::GetSchedulerInfoRequest &request)const;
+			void getSchedulerInfoAsync(const Model::GetSchedulerInfoRequest& request, const GetSchedulerInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetSchedulerInfoOutcomeCallable getSchedulerInfoCallable(const Model::GetSchedulerInfoRequest& request) const;
+			GetUserImageOutcome getUserImage(const Model::GetUserImageRequest &request)const;
+			void getUserImageAsync(const Model::GetUserImageRequest& request, const GetUserImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetUserImageOutcomeCallable getUserImageCallable(const Model::GetUserImageRequest& request) const;
+			GetVisualServiceStatusOutcome getVisualServiceStatus(const Model::GetVisualServiceStatusRequest &request)const;
+			void getVisualServiceStatusAsync(const Model::GetVisualServiceStatusRequest& request, const GetVisualServiceStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVisualServiceStatusOutcomeCallable getVisualServiceStatusCallable(const Model::GetVisualServiceStatusRequest& request) const;
+			InitializeEHPCOutcome initializeEHPC(const Model::InitializeEHPCRequest &request)const;
+			void initializeEHPCAsync(const Model::InitializeEHPCRequest& request, const InitializeEHPCAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			InitializeEHPCOutcomeCallable initializeEHPCCallable(const Model::InitializeEHPCRequest& request) const;
+			InspectImageOutcome inspectImage(const Model::InspectImageRequest &request)const;
+			void inspectImageAsync(const Model::InspectImageRequest& request, const InspectImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			InspectImageOutcomeCallable inspectImageCallable(const Model::InspectImageRequest& request) const;
+			InstallSoftwareOutcome installSoftware(const Model::InstallSoftwareRequest &request)const;
+			void installSoftwareAsync(const Model::InstallSoftwareRequest& request, const InstallSoftwareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			InstallSoftwareOutcomeCallable installSoftwareCallable(const Model::InstallSoftwareRequest& request) const;
+			InvokeShellCommandOutcome invokeShellCommand(const Model::InvokeShellCommandRequest &request)const;
+			void invokeShellCommandAsync(const Model::InvokeShellCommandRequest& request, const InvokeShellCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			InvokeShellCommandOutcomeCallable invokeShellCommandCallable(const Model::InvokeShellCommandRequest& request) const;
+			ListAvailableEcsTypesOutcome listAvailableEcsTypes(const Model::ListAvailableEcsTypesRequest &request)const;
+			void listAvailableEcsTypesAsync(const Model::ListAvailableEcsTypesRequest& request, const ListAvailableEcsTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAvailableEcsTypesOutcomeCallable listAvailableEcsTypesCallable(const Model::ListAvailableEcsTypesRequest& request) const;
+			ListCloudMetricProfilingsOutcome listCloudMetricProfilings(const Model::ListCloudMetricProfilingsRequest &request)const;
+			void listCloudMetricProfilingsAsync(const Model::ListCloudMetricProfilingsRequest& request, const ListCloudMetricProfilingsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListCloudMetricProfilingsOutcomeCallable listCloudMetricProfilingsCallable(const Model::ListCloudMetricProfilingsRequest& 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;
 			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;
+			ListClustersMetaOutcome listClustersMeta(const Model::ListClustersMetaRequest &request)const;
+			void listClustersMetaAsync(const Model::ListClustersMetaRequest& request, const ListClustersMetaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListClustersMetaOutcomeCallable listClustersMetaCallable(const Model::ListClustersMetaRequest& request) const;
+			ListCommandsOutcome listCommands(const Model::ListCommandsRequest &request)const;
+			void listCommandsAsync(const Model::ListCommandsRequest& request, const ListCommandsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListCommandsOutcomeCallable listCommandsCallable(const Model::ListCommandsRequest& request) const;
+			ListCommunityImagesOutcome listCommunityImages(const Model::ListCommunityImagesRequest &request)const;
+			void listCommunityImagesAsync(const Model::ListCommunityImagesRequest& request, const ListCommunityImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListCommunityImagesOutcomeCallable listCommunityImagesCallable(const Model::ListCommunityImagesRequest& request) const;
+			ListContainerAppsOutcome listContainerApps(const Model::ListContainerAppsRequest &request)const;
+			void listContainerAppsAsync(const Model::ListContainerAppsRequest& request, const ListContainerAppsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListContainerAppsOutcomeCallable listContainerAppsCallable(const Model::ListContainerAppsRequest& request) const;
+			ListContainerImagesOutcome listContainerImages(const Model::ListContainerImagesRequest &request)const;
+			void listContainerImagesAsync(const Model::ListContainerImagesRequest& request, const ListContainerImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListContainerImagesOutcomeCallable listContainerImagesCallable(const Model::ListContainerImagesRequest& request) const;
+			ListCpfsFileSystemsOutcome listCpfsFileSystems(const Model::ListCpfsFileSystemsRequest &request)const;
+			void listCpfsFileSystemsAsync(const Model::ListCpfsFileSystemsRequest& request, const ListCpfsFileSystemsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListCpfsFileSystemsOutcomeCallable listCpfsFileSystemsCallable(const Model::ListCpfsFileSystemsRequest& 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;
 			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;
+			ListFileSystemWithMountTargetsOutcome listFileSystemWithMountTargets(const Model::ListFileSystemWithMountTargetsRequest &request)const;
+			void listFileSystemWithMountTargetsAsync(const Model::ListFileSystemWithMountTargetsRequest& request, const ListFileSystemWithMountTargetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFileSystemWithMountTargetsOutcomeCallable listFileSystemWithMountTargetsCallable(const Model::ListFileSystemWithMountTargetsRequest& 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;
+			ListInstalledSoftwareOutcome listInstalledSoftware(const Model::ListInstalledSoftwareRequest &request)const;
+			void listInstalledSoftwareAsync(const Model::ListInstalledSoftwareRequest& request, const ListInstalledSoftwareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListInstalledSoftwareOutcomeCallable listInstalledSoftwareCallable(const Model::ListInstalledSoftwareRequest& request) const;
+			ListInvocationResultsOutcome listInvocationResults(const Model::ListInvocationResultsRequest &request)const;
+			void listInvocationResultsAsync(const Model::ListInvocationResultsRequest& request, const ListInvocationResultsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListInvocationResultsOutcomeCallable listInvocationResultsCallable(const Model::ListInvocationResultsRequest& request) const;
+			ListInvocationStatusOutcome listInvocationStatus(const Model::ListInvocationStatusRequest &request)const;
+			void listInvocationStatusAsync(const Model::ListInvocationStatusRequest& request, const ListInvocationStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListInvocationStatusOutcomeCallable listInvocationStatusCallable(const Model::ListInvocationStatusRequest& 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;
 			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;
+			ListJobsWithFiltersOutcome listJobsWithFilters(const Model::ListJobsWithFiltersRequest &request)const;
+			void listJobsWithFiltersAsync(const Model::ListJobsWithFiltersRequest& request, const ListJobsWithFiltersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListJobsWithFiltersOutcomeCallable listJobsWithFiltersCallable(const Model::ListJobsWithFiltersRequest& 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;
+			ListNodesByQueueOutcome listNodesByQueue(const Model::ListNodesByQueueRequest &request)const;
+			void listNodesByQueueAsync(const Model::ListNodesByQueueRequest& request, const ListNodesByQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListNodesByQueueOutcomeCallable listNodesByQueueCallable(const Model::ListNodesByQueueRequest& 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;
 			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;
+			ListQueuesOutcome listQueues(const Model::ListQueuesRequest &request)const;
+			void listQueuesAsync(const Model::ListQueuesRequest& request, const ListQueuesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListQueuesOutcomeCallable listQueuesCallable(const Model::ListQueuesRequest& 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;
+			ListSecurityGroupsOutcome listSecurityGroups(const Model::ListSecurityGroupsRequest &request)const;
+			void listSecurityGroupsAsync(const Model::ListSecurityGroupsRequest& request, const ListSecurityGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListSecurityGroupsOutcomeCallable listSecurityGroupsCallable(const Model::ListSecurityGroupsRequest& 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;
+			ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
+			void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
+			ListTasksOutcome listTasks(const Model::ListTasksRequest &request)const;
+			void listTasksAsync(const Model::ListTasksRequest& request, const ListTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListTasksOutcomeCallable listTasksCallable(const Model::ListTasksRequest& request) const;
+			ListUpgradeClientsOutcome listUpgradeClients(const Model::ListUpgradeClientsRequest &request)const;
+			void listUpgradeClientsAsync(const Model::ListUpgradeClientsRequest& request, const ListUpgradeClientsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListUpgradeClientsOutcomeCallable listUpgradeClientsCallable(const Model::ListUpgradeClientsRequest& 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;
+			ListUsersAsyncOutcome listUsersAsync(const Model::ListUsersAsyncRequest &request)const;
+			void listUsersAsyncAsync(const Model::ListUsersAsyncRequest& request, const ListUsersAsyncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListUsersAsyncOutcomeCallable listUsersAsyncCallable(const Model::ListUsersAsyncRequest& 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;
 			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;
+			ModifyContainerAppAttributesOutcome modifyContainerAppAttributes(const Model::ModifyContainerAppAttributesRequest &request)const;
+			void modifyContainerAppAttributesAsync(const Model::ModifyContainerAppAttributesRequest& request, const ModifyContainerAppAttributesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyContainerAppAttributesOutcomeCallable modifyContainerAppAttributesCallable(const Model::ModifyContainerAppAttributesRequest& request) const;
+			ModifyImageGatewayConfigOutcome modifyImageGatewayConfig(const Model::ModifyImageGatewayConfigRequest &request)const;
+			void modifyImageGatewayConfigAsync(const Model::ModifyImageGatewayConfigRequest& request, const ModifyImageGatewayConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyImageGatewayConfigOutcomeCallable modifyImageGatewayConfigCallable(const Model::ModifyImageGatewayConfigRequest& 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;
 			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;
+			ModifyVisualServicePasswdOutcome modifyVisualServicePasswd(const Model::ModifyVisualServicePasswdRequest &request)const;
+			void modifyVisualServicePasswdAsync(const Model::ModifyVisualServicePasswdRequest& request, const ModifyVisualServicePasswdAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyVisualServicePasswdOutcomeCallable modifyVisualServicePasswdCallable(const Model::ModifyVisualServicePasswdRequest& request) const;
+			MountNFSOutcome mountNFS(const Model::MountNFSRequest &request)const;
+			void mountNFSAsync(const Model::MountNFSRequest& request, const MountNFSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			MountNFSOutcomeCallable mountNFSCallable(const Model::MountNFSRequest& request) const;
+			PullImageOutcome pullImage(const Model::PullImageRequest &request)const;
+			void pullImageAsync(const Model::PullImageRequest& request, const PullImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PullImageOutcomeCallable pullImageCallable(const Model::PullImageRequest& request) const;
+			QueryServicePackAndPriceOutcome queryServicePackAndPrice(const Model::QueryServicePackAndPriceRequest &request)const;
+			void queryServicePackAndPriceAsync(const Model::QueryServicePackAndPriceRequest& request, const QueryServicePackAndPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			QueryServicePackAndPriceOutcomeCallable queryServicePackAndPriceCallable(const Model::QueryServicePackAndPriceRequest& request) const;
+			RecoverClusterOutcome recoverCluster(const Model::RecoverClusterRequest &request)const;
+			void recoverClusterAsync(const Model::RecoverClusterRequest& request, const RecoverClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RecoverClusterOutcomeCallable recoverClusterCallable(const Model::RecoverClusterRequest& 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;
+			RunCloudMetricProfilingOutcome runCloudMetricProfiling(const Model::RunCloudMetricProfilingRequest &request)const;
+			void runCloudMetricProfilingAsync(const Model::RunCloudMetricProfilingRequest& request, const RunCloudMetricProfilingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RunCloudMetricProfilingOutcomeCallable runCloudMetricProfilingCallable(const Model::RunCloudMetricProfilingRequest& 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;
-			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;
+			SetGWSClusterPolicyOutcome setGWSClusterPolicy(const Model::SetGWSClusterPolicyRequest &request)const;
+			void setGWSClusterPolicyAsync(const Model::SetGWSClusterPolicyRequest& request, const SetGWSClusterPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetGWSClusterPolicyOutcomeCallable setGWSClusterPolicyCallable(const Model::SetGWSClusterPolicyRequest& request) const;
+			SetGWSInstanceNameOutcome setGWSInstanceName(const Model::SetGWSInstanceNameRequest &request)const;
+			void setGWSInstanceNameAsync(const Model::SetGWSInstanceNameRequest& request, const SetGWSInstanceNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetGWSInstanceNameOutcomeCallable setGWSInstanceNameCallable(const Model::SetGWSInstanceNameRequest& request) const;
+			SetGWSInstanceUserOutcome setGWSInstanceUser(const Model::SetGWSInstanceUserRequest &request)const;
+			void setGWSInstanceUserAsync(const Model::SetGWSInstanceUserRequest& request, const SetGWSInstanceUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetGWSInstanceUserOutcomeCallable setGWSInstanceUserCallable(const Model::SetGWSInstanceUserRequest& request) const;
+			SetPostScriptsOutcome setPostScripts(const Model::SetPostScriptsRequest &request)const;
+			void setPostScriptsAsync(const Model::SetPostScriptsRequest& request, const SetPostScriptsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetPostScriptsOutcomeCallable setPostScriptsCallable(const Model::SetPostScriptsRequest& request) const;
+			SetQueueOutcome setQueue(const Model::SetQueueRequest &request)const;
+			void setQueueAsync(const Model::SetQueueRequest& request, const SetQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetQueueOutcomeCallable setQueueCallable(const Model::SetQueueRequest& request) const;
+			SetSchedulerInfoOutcome setSchedulerInfo(const Model::SetSchedulerInfoRequest &request)const;
+			void setSchedulerInfoAsync(const Model::SetSchedulerInfoRequest& request, const SetSchedulerInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetSchedulerInfoOutcomeCallable setSchedulerInfoCallable(const Model::SetSchedulerInfoRequest& request) const;
+			StartClusterOutcome startCluster(const Model::StartClusterRequest &request)const;
+			void startClusterAsync(const Model::StartClusterRequest& request, const StartClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartClusterOutcomeCallable startClusterCallable(const Model::StartClusterRequest& request) const;
+			StartGWSInstanceOutcome startGWSInstance(const Model::StartGWSInstanceRequest &request)const;
+			void startGWSInstanceAsync(const Model::StartGWSInstanceRequest& request, const StartGWSInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartGWSInstanceOutcomeCallable startGWSInstanceCallable(const Model::StartGWSInstanceRequest& request) const;
+			StartNodesOutcome startNodes(const Model::StartNodesRequest &request)const;
+			void startNodesAsync(const Model::StartNodesRequest& request, const StartNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartNodesOutcomeCallable startNodesCallable(const Model::StartNodesRequest& request) const;
+			StartVisualServiceOutcome startVisualService(const Model::StartVisualServiceRequest &request)const;
+			void startVisualServiceAsync(const Model::StartVisualServiceRequest& request, const StartVisualServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartVisualServiceOutcomeCallable startVisualServiceCallable(const Model::StartVisualServiceRequest& request) const;
+			StopClusterOutcome stopCluster(const Model::StopClusterRequest &request)const;
+			void stopClusterAsync(const Model::StopClusterRequest& request, const StopClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopClusterOutcomeCallable stopClusterCallable(const Model::StopClusterRequest& request) const;
+			StopGWSInstanceOutcome stopGWSInstance(const Model::StopGWSInstanceRequest &request)const;
+			void stopGWSInstanceAsync(const Model::StopGWSInstanceRequest& request, const StopGWSInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopGWSInstanceOutcomeCallable stopGWSInstanceCallable(const Model::StopGWSInstanceRequest& 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;
+			StopNodesOutcome stopNodes(const Model::StopNodesRequest &request)const;
+			void stopNodesAsync(const Model::StopNodesRequest& request, const StopNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopNodesOutcomeCallable stopNodesCallable(const Model::StopNodesRequest& request) const;
+			StopVisualServiceOutcome stopVisualService(const Model::StopVisualServiceRequest &request)const;
+			void stopVisualServiceAsync(const Model::StopVisualServiceRequest& request, const StopVisualServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopVisualServiceOutcomeCallable stopVisualServiceCallable(const Model::StopVisualServiceRequest& 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;
+			SummaryImagesOutcome summaryImages(const Model::SummaryImagesRequest &request)const;
+			void summaryImagesAsync(const Model::SummaryImagesRequest& request, const SummaryImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SummaryImagesOutcomeCallable summaryImagesCallable(const Model::SummaryImagesRequest& request) const;
+			SummaryImagesInfoOutcome summaryImagesInfo(const Model::SummaryImagesInfoRequest &request)const;
+			void summaryImagesInfoAsync(const Model::SummaryImagesInfoRequest& request, const SummaryImagesInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SummaryImagesInfoOutcomeCallable summaryImagesInfoCallable(const Model::SummaryImagesInfoRequest& request) const;
+			SyncUsersOutcome syncUsers(const Model::SyncUsersRequest &request)const;
+			void syncUsersAsync(const Model::SyncUsersRequest& request, const SyncUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SyncUsersOutcomeCallable syncUsersCallable(const Model::SyncUsersRequest& request) const;
+			TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
+			void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
+			UnTagResourcesOutcome unTagResources(const Model::UnTagResourcesRequest &request)const;
+			void unTagResourcesAsync(const Model::UnTagResourcesRequest& request, const UnTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UnTagResourcesOutcomeCallable unTagResourcesCallable(const Model::UnTagResourcesRequest& request) const;
+			UninstallSoftwareOutcome uninstallSoftware(const Model::UninstallSoftwareRequest &request)const;
+			void uninstallSoftwareAsync(const Model::UninstallSoftwareRequest& request, const UninstallSoftwareAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UninstallSoftwareOutcomeCallable uninstallSoftwareCallable(const Model::UninstallSoftwareRequest& request) const;
+			UpdateClusterVolumesOutcome updateClusterVolumes(const Model::UpdateClusterVolumesRequest &request)const;
+			void updateClusterVolumesAsync(const Model::UpdateClusterVolumesRequest& request, const UpdateClusterVolumesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateClusterVolumesOutcomeCallable updateClusterVolumesCallable(const Model::UpdateClusterVolumesRequest& request) const;
+			UpdateQueueConfigOutcome updateQueueConfig(const Model::UpdateQueueConfigRequest &request)const;
+			void updateQueueConfigAsync(const Model::UpdateQueueConfigRequest& request, const UpdateQueueConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateQueueConfigOutcomeCallable updateQueueConfigCallable(const Model::UpdateQueueConfigRequest& 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;

ehpc/include/alibabacloud/ehpc/model/AddContainerAppRequest.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_ADDCONTAINERAPPREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDCONTAINERAPPREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT AddContainerAppRequest : public RpcServiceRequest {
+public:
+	AddContainerAppRequest();
+	~AddContainerAppRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getRepository() const;
+	void setRepository(const std::string &repository);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getContainerType() const;
+	void setContainerType(const std::string &containerType);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getImageTag() const;
+	void setImageTag(const std::string &imageTag);
+
+private:
+	std::string description_;
+	std::string repository_;
+	std::string accessKeyId_;
+	std::string containerType_;
+	std::string name_;
+	std::string imageTag_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDCONTAINERAPPREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/AddContainerAppResult.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_ADDCONTAINERAPPRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDCONTAINERAPPRESULT_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 AddContainerAppResult : public ServiceResult
+			{
+			public:
+
+
+				AddContainerAppResult();
+				explicit AddContainerAppResult(const std::string &payload);
+				~AddContainerAppResult();
+				std::vector<std::string> getContainerId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> containerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDCONTAINERAPPRESULT_H_

ehpc/include/alibabacloud/ehpc/model/AddExistedNodesRequest.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_ADDEXISTEDNODESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT AddExistedNodesRequest : public RpcServiceRequest {
+public:
+	struct Instance {
+		std::string id;
+	};
+	AddExistedNodesRequest();
+	~AddExistedNodesRequest();
+	std::string getImageId() const;
+	void setImageId(const std::string &imageId);
+	std::vector<Instance> getInstance() const;
+	void setInstance(const std::vector<Instance> &instance);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getJobQueue() const;
+	void setJobQueue(const std::string &jobQueue);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getImageOwnerAlias() const;
+	void setImageOwnerAlias(const std::string &imageOwnerAlias);
+
+private:
+	std::string imageId_;
+	std::vector<Instance> instance_;
+	std::string clusterId_;
+	std::string jobQueue_;
+	std::string accessKeyId_;
+	std::string imageOwnerAlias_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/AddExistedNodesResult.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_ADDEXISTEDNODESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESRESULT_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 AddExistedNodesResult : public ServiceResult
+			{
+			public:
+
+
+				AddExistedNodesResult();
+				explicit AddExistedNodesResult(const std::string &payload);
+				~AddExistedNodesResult();
+				std::string getTaskId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string taskId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDEXISTEDNODESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/AddLocalNodesRequest.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_ADDLOCALNODESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDLOCALNODESREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT AddLocalNodesRequest : public RpcServiceRequest {
+public:
+	AddLocalNodesRequest();
+	~AddLocalNodesRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getNodes() const;
+	void setNodes(const std::string &nodes);
+	std::string getQueue() const;
+	void setQueue(const std::string &queue);
+
+private:
+	std::string clusterId_;
+	std::string accessKeyId_;
+	std::string nodes_;
+	std::string queue_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDLOCALNODESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/AddLocalNodesResult.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_ADDLOCALNODESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDLOCALNODESRESULT_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 AddLocalNodesResult : public ServiceResult
+			{
+			public:
+
+
+				AddLocalNodesResult();
+				explicit AddLocalNodesResult(const std::string &payload);
+				~AddLocalNodesResult();
+				std::vector<std::string> getInstanceIds()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<std::string> instanceIds_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDLOCALNODESRESULT_H_

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

@@ -28,31 +28,111 @@ namespace EHPC {
 namespace Model {
 class ALIBABACLOUD_EHPC_EXPORT AddNodesRequest : public RpcServiceRequest {
 public:
+	struct DataDisks {
+		bool dataDiskDeleteWithInstance;
+		bool dataDiskEncrypted;
+		std::string dataDiskKMSKeyId;
+		int dataDiskSize;
+		std::string dataDiskCategory;
+		std::string dataDiskPerformanceLevel;
+	};
 	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 getSystemDiskLevel() const;
+	void setSystemDiskLevel(const std::string &systemDiskLevel);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	bool getAllocatePublicAddress() const;
+	void setAllocatePublicAddress(bool allocatePublicAddress);
+	int getInternetMaxBandWidthOut() const;
+	void setInternetMaxBandWidthOut(int internetMaxBandWidthOut);
+	std::string getJobQueue() const;
+	void setJobQueue(const std::string &jobQueue);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
 	std::string getImageOwnerAlias() const;
 	void setImageOwnerAlias(const std::string &imageOwnerAlias);
+	std::string getSystemDiskType() const;
+	void setSystemDiskType(const std::string &systemDiskType);
+	std::vector<DataDisks> getDataDisks() const;
+	void setDataDisks(const std::vector<DataDisks> &dataDisks);
+	int getMinCount() const;
+	void setMinCount(int minCount);
+	int getSystemDiskSize() const;
+	void setSystemDiskSize(int systemDiskSize);
+	std::string getInstanceType() const;
+	void setInstanceType(const std::string &instanceType);
+	std::string getHostNamePrefix() const;
+	void setHostNamePrefix(const std::string &hostNamePrefix);
 	std::string getComputeSpotPriceLimit() const;
 	void setComputeSpotPriceLimit(const std::string &computeSpotPriceLimit);
+	int getAutoRenewPeriod() const;
+	void setAutoRenewPeriod(int autoRenewPeriod);
+	int getPeriod() const;
+	void setPeriod(int period);
+	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 getHostNameSuffix() const;
+	void setHostNameSuffix(const std::string &hostNameSuffix);
+	bool getSync() const;
+	void setSync(bool sync);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getPeriodUnit() const;
+	void setPeriodUnit(const std::string &periodUnit);
+	bool getComputeEnableHt() const;
+	void setComputeEnableHt(bool computeEnableHt);
+	std::string getAutoRenew() const;
+	void setAutoRenew(const std::string &autoRenew);
+	std::string getEcsChargeType() const;
+	void setEcsChargeType(const std::string &ecsChargeType);
+	std::string getInternetChargeType() const;
+	void setInternetChargeType(const std::string &internetChargeType);
+	std::string getCreateMode() const;
+	void setCreateMode(const std::string &createMode);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	int getInternetMaxBandWidthIn() const;
+	void setInternetMaxBandWidthIn(int internetMaxBandWidthIn);
 
 private:
 	std::string imageId_;
-	int count_;
-	std::string clusterId_;
-	std::string computeSpotStrategy_;
+	std::string systemDiskLevel_;
+	std::string clientToken_;
+	bool allocatePublicAddress_;
+	int internetMaxBandWidthOut_;
+	std::string jobQueue_;
 	std::string accessKeyId_;
 	std::string imageOwnerAlias_;
+	std::string systemDiskType_;
+	std::vector<DataDisks> dataDisks_;
+	int minCount_;
+	int systemDiskSize_;
+	std::string instanceType_;
+	std::string hostNamePrefix_;
 	std::string computeSpotPriceLimit_;
+	int autoRenewPeriod_;
+	int period_;
+	int count_;
+	std::string clusterId_;
+	std::string computeSpotStrategy_;
+	std::string hostNameSuffix_;
+	bool sync_;
+	std::string vSwitchId_;
+	std::string periodUnit_;
+	bool computeEnableHt_;
+	std::string autoRenew_;
+	std::string ecsChargeType_;
+	std::string internetChargeType_;
+	std::string createMode_;
+	std::string zoneId_;
+	int internetMaxBandWidthIn_;
 };
 } // namespace Model
 } // namespace EHPC

ehpc/include/alibabacloud/ehpc/model/AddNodesResult.h

@@ -37,11 +37,13 @@ namespace AlibabaCloud
 				AddNodesResult();
 				explicit AddNodesResult(const std::string &payload);
 				~AddNodesResult();
+				std::string getTaskId()const;
 				std::vector<std::string> getInstanceIds()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string taskId_;
 				std::vector<std::string> instanceIds_;
 
 			};

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

ehpc/include/alibabacloud/ehpc/model/SetJobUserResult.h → ehpc/include/alibabacloud/ehpc/model/AddQueueResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_EHPC_MODEL_SETJOBUSERRESULT_H_
-#define ALIBABACLOUD_EHPC_MODEL_SETJOBUSERRESULT_H_
+#ifndef ALIBABACLOUD_EHPC_MODEL_ADDQUEUERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDQUEUERESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_EHPC_EXPORT SetJobUserResult : public ServiceResult
+			class ALIBABACLOUD_EHPC_EXPORT AddQueueResult : public ServiceResult
 			{
 			public:
 
 
-				SetJobUserResult();
-				explicit SetJobUserResult(const std::string &payload);
-				~SetJobUserResult();
+				AddQueueResult();
+				explicit AddQueueResult(const std::string &payload);
+				~AddQueueResult();
 
 			protected:
 				void parse(const std::string &payload);
@@ -46,4 +46,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_EHPC_MODEL_SETJOBUSERRESULT_H_
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDQUEUERESULT_H_

ehpc/include/alibabacloud/ehpc/model/AddSecurityGroupRequest.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_ADDSECURITYGROUPREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDSECURITYGROUPREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT AddSecurityGroupRequest : public RpcServiceRequest {
+public:
+	AddSecurityGroupRequest();
+	~AddSecurityGroupRequest();
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getSecurityGroupId() const;
+	void setSecurityGroupId(const std::string &securityGroupId);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+
+private:
+	std::string clientToken_;
+	std::string securityGroupId_;
+	std::string clusterId_;
+	std::string accessKeyId_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDSECURITYGROUPREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/AddSecurityGroupResult.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_ADDSECURITYGROUPRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_ADDSECURITYGROUPRESULT_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 AddSecurityGroupResult : public ServiceResult
+			{
+			public:
+
+
+				AddSecurityGroupResult();
+				explicit AddSecurityGroupResult(const std::string &payload);
+				~AddSecurityGroupResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_ADDSECURITYGROUPRESULT_H_

ehpc/include/alibabacloud/ehpc/model/AddUsersRequest.h

@@ -39,15 +39,12 @@ public:
 	void setClusterId(const std::string &clusterId);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
-	bool getReleaseInstance() const;
-	void setReleaseInstance(bool releaseInstance);
 	std::vector<User> getUser() const;
 	void setUser(const std::vector<User> &user);
 
 private:
 	std::string clusterId_;
 	std::string accessKeyId_;
-	bool releaseInstance_;
 	std::vector<User> user_;
 };
 } // namespace Model

ehpc/include/alibabacloud/ehpc/model/ApplyNodesRequest.h

@@ -0,0 +1,136 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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_APPLYNODESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_APPLYNODESREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT ApplyNodesRequest : public RpcServiceRequest {
+public:
+	struct ZoneInfos {
+		std::string vSwitchId;
+		std::string zoneId;
+	};
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	struct InstanceTypeModel {
+		float maxPrice;
+		std::string targetImageId;
+		std::string instanceType;
+	};
+	ApplyNodesRequest();
+	~ApplyNodesRequest();
+	std::string getImageId() const;
+	void setImageId(const std::string &imageId);
+	int getMemory() const;
+	void setMemory(int memory);
+	std::string getSystemDiskLevel() const;
+	void setSystemDiskLevel(const std::string &systemDiskLevel);
+	bool getAllocatePublicAddress() const;
+	void setAllocatePublicAddress(bool allocatePublicAddress);
+	int getInternetMaxBandWidthOut() const;
+	void setInternetMaxBandWidthOut(int internetMaxBandWidthOut);
+	std::string getResourceAmountType() const;
+	void setResourceAmountType(const std::string &resourceAmountType);
+	bool getStrictResourceProvision() const;
+	void setStrictResourceProvision(bool strictResourceProvision);
+	std::string getJobQueue() const;
+	void setJobQueue(const std::string &jobQueue);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getSystemDiskType() const;
+	void setSystemDiskType(const std::string &systemDiskType);
+	int getCores() const;
+	void setCores(int cores);
+	int getSystemDiskSize() const;
+	void setSystemDiskSize(int systemDiskSize);
+	std::vector<ZoneInfos> getZoneInfos() const;
+	void setZoneInfos(const std::vector<ZoneInfos> &zoneInfos);
+	std::string getHostNamePrefix() const;
+	void setHostNamePrefix(const std::string &hostNamePrefix);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	float getComputeSpotPriceLimit() const;
+	void setComputeSpotPriceLimit(float computeSpotPriceLimit);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getComputeSpotStrategy() const;
+	void setComputeSpotStrategy(const std::string &computeSpotStrategy);
+	std::string getHostNameSuffix() const;
+	void setHostNameSuffix(const std::string &hostNameSuffix);
+	std::string getPriorityStrategy() const;
+	void setPriorityStrategy(const std::string &priorityStrategy);
+	std::string getInstanceFamilyLevel() const;
+	void setInstanceFamilyLevel(const std::string &instanceFamilyLevel);
+	int getRound() const;
+	void setRound(int round);
+	std::string getInternetChargeType() const;
+	void setInternetChargeType(const std::string &internetChargeType);
+	int getInterval() const;
+	void setInterval(int interval);
+	std::vector<InstanceTypeModel> getInstanceTypeModel() const;
+	void setInstanceTypeModel(const std::vector<InstanceTypeModel> &instanceTypeModel);
+	int getInternetMaxBandWidthIn() const;
+	void setInternetMaxBandWidthIn(int internetMaxBandWidthIn);
+	int getTargetCapacity() const;
+	void setTargetCapacity(int targetCapacity);
+	bool getStrictSatisfiedTargetCapacity() const;
+	void setStrictSatisfiedTargetCapacity(bool strictSatisfiedTargetCapacity);
+
+private:
+	std::string imageId_;
+	int memory_;
+	std::string systemDiskLevel_;
+	bool allocatePublicAddress_;
+	int internetMaxBandWidthOut_;
+	std::string resourceAmountType_;
+	bool strictResourceProvision_;
+	std::string jobQueue_;
+	std::string accessKeyId_;
+	std::string systemDiskType_;
+	int cores_;
+	int systemDiskSize_;
+	std::vector<ZoneInfos> zoneInfos_;
+	std::string hostNamePrefix_;
+	std::vector<Tag> tag_;
+	float computeSpotPriceLimit_;
+	std::string clusterId_;
+	std::string computeSpotStrategy_;
+	std::string hostNameSuffix_;
+	std::string priorityStrategy_;
+	std::string instanceFamilyLevel_;
+	int round_;
+	std::string internetChargeType_;
+	int interval_;
+	std::vector<InstanceTypeModel> instanceTypeModel_;
+	int internetMaxBandWidthIn_;
+	int targetCapacity_;
+	bool strictSatisfiedTargetCapacity_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_APPLYNODESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/ApplyNodesResult.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_APPLYNODESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_APPLYNODESRESULT_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 ApplyNodesResult : public ServiceResult
+			{
+			public:
+
+
+				ApplyNodesResult();
+				explicit ApplyNodesResult(const std::string &payload);
+				~ApplyNodesResult();
+				std::string getTaskId()const;
+				int getSatisfiedAmount()const;
+				std::vector<std::string> getInstanceIds()const;
+				std::string getDetail()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string taskId_;
+				int satisfiedAmount_;
+				std::vector<std::string> instanceIds_;
+				std::string detail_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_APPLYNODESRESULT_H_

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

@@ -28,112 +28,216 @@ namespace EHPC {
 namespace Model {
 class ALIBABACLOUD_EHPC_EXPORT CreateClusterRequest : public RpcServiceRequest {
 public:
+	struct AdditionalVolumes {
+		std::string volumeType;
+		std::string volumeMountOption;
+		std::string volumeProtocol;
+		std::string localDirectory;
+		std::string remoteDirectory;
+		struct Roles {
+			std::string name;
+		};
+		std::vector<Roles> roles;
+		std::string volumeId;
+		std::string volumeMountpoint;
+		std::string location;
+		std::string jobQueue;
+	};
+	struct Tag {
+		std::string value;
+		std::string key;
+	};
+	struct PostInstallScript {
+		std::string args;
+		std::string url;
+	};
 	struct Application {
 		std::string tag;
 	};
 	CreateClusterRequest();
 	~CreateClusterRequest();
-	std::string getSccClusterId() const;
-	void setSccClusterId(const std::string &sccClusterId);
-	std::string getImageId() const;
-	void setImageId(const std::string &imageId);
+	std::vector<AdditionalVolumes> getAdditionalVolumes() const;
+	void setAdditionalVolumes(const std::vector<AdditionalVolumes> &additionalVolumes);
 	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);
+	std::string getDeployMode() const;
+	void setDeployMode(const std::string &deployMode);
 	int getEcsOrderManagerCount() const;
 	void setEcsOrderManagerCount(int ecsOrderManagerCount);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
 	std::string getPassword() const;
 	void setPassword(const std::string &password);
 	int getEcsOrderLoginCount() const;
 	void setEcsOrderLoginCount(int ecsOrderLoginCount);
+	bool getWithoutElasticIp() const;
+	void setWithoutElasticIp(bool withoutElasticIp);
+	std::string getRemoteVisEnable() const;
+	void setRemoteVisEnable(const std::string &remoteVisEnable);
+	int getSystemDiskSize() const;
+	void setSystemDiskSize(int systemDiskSize);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
 	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);
+	int getAutoRenewPeriod() const;
+	void setAutoRenewPeriod(int autoRenewPeriod);
+	int getPeriod() const;
+	void setPeriod(int period);
 	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::vector<PostInstallScript> getPostInstallScript() const;
+	void setPostInstallScript(const std::vector<PostInstallScript> &postInstallScript);
+	std::vector<std::string> getRamNodeTypes() const;
+	void setRamNodeTypes(const std::vector<std::string> &ramNodeTypes);
 	std::string getVSwitchId() const;
 	void setVSwitchId(const std::string &vSwitchId);
+	std::string getPeriodUnit() const;
+	void setPeriodUnit(const std::string &periodUnit);
+	bool getComputeEnableHt() const;
+	void setComputeEnableHt(bool computeEnableHt);
+	std::string getAutoRenew() const;
+	void setAutoRenew(const std::string &autoRenew);
+	std::string getDomain() const;
+	void setDomain(const std::string &domain);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getVolumeId() const;
+	void setVolumeId(const std::string &volumeId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getSccClusterId() const;
+	void setSccClusterId(const std::string &sccClusterId);
+	std::string getVolumeMountOption() const;
+	void setVolumeMountOption(const std::string &volumeMountOption);
+	std::string getImageId() const;
+	void setImageId(const std::string &imageId);
+	std::string getSystemDiskLevel() const;
+	void setSystemDiskLevel(const std::string &systemDiskLevel);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	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 getEcsOrderComputeInstanceType() const;
+	void setEcsOrderComputeInstanceType(const std::string &ecsOrderComputeInstanceType);
+	std::string getJobQueue() const;
+	void setJobQueue(const std::string &jobQueue);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getVolumeType() const;
+	void setVolumeType(const std::string &volumeType);
+	std::string getSystemDiskType() const;
+	void setSystemDiskType(const std::string &systemDiskType);
+	std::string getVolumeProtocol() const;
+	void setVolumeProtocol(const std::string &volumeProtocol);
+	std::string getClientVersion() const;
+	void setClientVersion(const std::string &clientVersion);
+	std::string getOsTag() const;
+	void setOsTag(const std::string &osTag);
+	std::string getClusterVersion() const;
+	void setClusterVersion(const std::string &clusterVersion);
+	bool getIsComputeEss() const;
+	void setIsComputeEss(bool isComputeEss);
+	std::string getRamRoleName() const;
+	void setRamRoleName(const std::string &ramRoleName);
+	std::string getPlugin() const;
+	void setPlugin(const std::string &plugin);
 	std::vector<Application> getApplication() const;
 	void setApplication(const std::vector<Application> &application);
 	std::string getEcsChargeType() const;
 	void setEcsChargeType(const std::string &ecsChargeType);
+	std::string getInputFileUrl() const;
+	void setInputFileUrl(const std::string &inputFileUrl);
 	std::string getVpcId() const;
 	void setVpcId(const std::string &vpcId);
 	bool getHaEnable() const;
 	void setHaEnable(bool haEnable);
-	std::string getName() const;
-	void setName(const std::string &name);
+	bool getWithoutAgent() const;
+	void setWithoutAgent(bool withoutAgent);
 	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::vector<AdditionalVolumes> additionalVolumes_;
 	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_;
+	std::string deployMode_;
 	int ecsOrderManagerCount_;
+	std::string resourceGroupId_;
 	std::string password_;
 	int ecsOrderLoginCount_;
+	bool withoutElasticIp_;
+	std::string remoteVisEnable_;
+	int systemDiskSize_;
+	std::vector<Tag> tag_;
 	std::string computeSpotPriceLimit_;
-	std::string volumeProtocol_;
-	std::string osTag_;
+	int autoRenewPeriod_;
+	int period_;
 	std::string remoteDirectory_;
 	int ecsOrderComputeCount_;
 	std::string computeSpotStrategy_;
+	std::vector<PostInstallScript> postInstallScript_;
+	std::vector<std::string> ramNodeTypes_;
 	std::string vSwitchId_;
+	std::string periodUnit_;
+	bool computeEnableHt_;
+	std::string autoRenew_;
+	std::string domain_;
+	std::string name_;
+	std::string volumeId_;
+	std::string zoneId_;
+	std::string sccClusterId_;
+	std::string volumeMountOption_;
+	std::string imageId_;
+	std::string systemDiskLevel_;
+	std::string clientToken_;
+	std::string ehpcVersion_;
+	std::string accountType_;
+	std::string securityGroupId_;
+	std::string description_;
+	std::string ecsOrderComputeInstanceType_;
+	std::string jobQueue_;
+	std::string accessKeyId_;
+	std::string volumeType_;
+	std::string systemDiskType_;
+	std::string volumeProtocol_;
+	std::string clientVersion_;
+	std::string osTag_;
+	std::string clusterVersion_;
+	bool isComputeEss_;
+	std::string ramRoleName_;
+	std::string plugin_;
 	std::vector<Application> application_;
 	std::string ecsChargeType_;
+	std::string inputFileUrl_;
 	std::string vpcId_;
 	bool haEnable_;
-	std::string name_;
+	bool withoutAgent_;
 	std::string schedulerType_;
-	std::string volumeId_;
 	std::string volumeMountpoint_;
 	std::string ecsOrderLoginInstanceType_;
-	std::string zoneId_;
 };
 } // namespace Model
 } // namespace EHPC

ehpc/include/alibabacloud/ehpc/model/CreateClusterResult.h

@@ -37,11 +37,13 @@ namespace AlibabaCloud
 				CreateClusterResult();
 				explicit CreateClusterResult(const std::string &payload);
 				~CreateClusterResult();
+				std::string getTaskId()const;
 				std::string getClusterId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string taskId_;
 				std::string clusterId_;
 
 			};

ehpc/include/alibabacloud/ehpc/model/CreateGWSClusterRequest.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_CREATEGWSCLUSTERREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEGWSCLUSTERREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT CreateGWSClusterRequest : public RpcServiceRequest {
+public:
+	CreateGWSClusterRequest();
+	~CreateGWSClusterRequest();
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getClusterType() const;
+	void setClusterType(const std::string &clusterType);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	std::string getName() const;
+	void setName(const std::string &name);
+
+private:
+	std::string accessKeyId_;
+	std::string clusterType_;
+	std::string vSwitchId_;
+	std::string vpcId_;
+	std::string name_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEGWSCLUSTERREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/CreateGWSClusterResult.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_CREATEGWSCLUSTERRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEGWSCLUSTERRESULT_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 CreateGWSClusterResult : public ServiceResult
+			{
+			public:
+
+
+				CreateGWSClusterResult();
+				explicit CreateGWSClusterResult(const std::string &payload);
+				~CreateGWSClusterResult();
+				std::string getClusterId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEGWSCLUSTERRESULT_H_

ehpc/include/alibabacloud/ehpc/model/CreateGWSImageRequest.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_CREATEGWSIMAGEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEGWSIMAGEREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT CreateGWSImageRequest : public RpcServiceRequest {
+public:
+	CreateGWSImageRequest();
+	~CreateGWSImageRequest();
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getName() const;
+	void setName(const std::string &name);
+
+private:
+	std::string accessKeyId_;
+	std::string instanceId_;
+	std::string name_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEGWSIMAGEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/CreateGWSImageResult.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_CREATEGWSIMAGERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEGWSIMAGERESULT_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 CreateGWSImageResult : public ServiceResult
+			{
+			public:
+
+
+				CreateGWSImageResult();
+				explicit CreateGWSImageResult(const std::string &payload);
+				~CreateGWSImageResult();
+				std::string getImageId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string imageId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEGWSIMAGERESULT_H_

ehpc/include/alibabacloud/ehpc/model/CreateGWSInstanceRequest.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_CREATEGWSINSTANCEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEGWSINSTANCEREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT CreateGWSInstanceRequest : public RpcServiceRequest {
+public:
+	CreateGWSInstanceRequest();
+	~CreateGWSInstanceRequest();
+	std::string getImageId() const;
+	void setImageId(const std::string &imageId);
+	bool getAllocatePublicAddress() const;
+	void setAllocatePublicAddress(bool allocatePublicAddress);
+	std::string getAppList() const;
+	void setAppList(const std::string &appList);
+	int getInternetMaxBandwidthOut() const;
+	void setInternetMaxBandwidthOut(int internetMaxBandwidthOut);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getSystemDiskCategory() const;
+	void setSystemDiskCategory(const std::string &systemDiskCategory);
+	int getSystemDiskSize() const;
+	void setSystemDiskSize(int systemDiskSize);
+	std::string getInstanceType() const;
+	void setInstanceType(const std::string &instanceType);
+	std::string getInstanceChargeType() const;
+	void setInstanceChargeType(const std::string &instanceChargeType);
+	std::string getPeriod() const;
+	void setPeriod(const std::string &period);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getWorkMode() const;
+	void setWorkMode(const std::string &workMode);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getPeriodUnit() const;
+	void setPeriodUnit(const std::string &periodUnit);
+	bool getAutoRenew() const;
+	void setAutoRenew(bool autoRenew);
+	std::string getInternetChargeType() const;
+	void setInternetChargeType(const std::string &internetChargeType);
+	std::string getName() const;
+	void setName(const std::string &name);
+	int getInternetMaxBandwidthIn() const;
+	void setInternetMaxBandwidthIn(int internetMaxBandwidthIn);
+
+private:
+	std::string imageId_;
+	bool allocatePublicAddress_;
+	std::string appList_;
+	int internetMaxBandwidthOut_;
+	std::string accessKeyId_;
+	std::string systemDiskCategory_;
+	int systemDiskSize_;
+	std::string instanceType_;
+	std::string instanceChargeType_;
+	std::string period_;
+	std::string clusterId_;
+	std::string workMode_;
+	std::string vSwitchId_;
+	std::string periodUnit_;
+	bool autoRenew_;
+	std::string internetChargeType_;
+	std::string name_;
+	int internetMaxBandwidthIn_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEGWSINSTANCEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/CreateGWSInstanceResult.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_CREATEGWSINSTANCERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEGWSINSTANCERESULT_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 CreateGWSInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				CreateGWSInstanceResult();
+				explicit CreateGWSInstanceResult(const std::string &payload);
+				~CreateGWSInstanceResult();
+				std::string getInstanceId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEGWSINSTANCERESULT_H_

ehpc/include/alibabacloud/ehpc/model/CreateHybridClusterRequest.h

@@ -0,0 +1,168 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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_CREATEHYBRIDCLUSTERREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEHYBRIDCLUSTERREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT CreateHybridClusterRequest : public RpcServiceRequest {
+public:
+	struct PostInstallScript {
+		std::string args;
+		std::string url;
+	};
+	struct Nodes {
+		std::string ipAddress;
+		std::string hostName;
+		std::string role;
+		std::string schedulerType;
+		std::string accountType;
+		std::string dir;
+	};
+	struct Application {
+		std::string tag;
+	};
+	CreateHybridClusterRequest();
+	~CreateHybridClusterRequest();
+	std::string getEcsOrderManagerInstanceType() const;
+	void setEcsOrderManagerInstanceType(const std::string &ecsOrderManagerInstanceType);
+	std::string getKeyPairName() const;
+	void setKeyPairName(const std::string &keyPairName);
+	bool getMultiOs() const;
+	void setMultiOs(bool multiOs);
+	std::string getSecurityGroupName() const;
+	void setSecurityGroupName(const std::string &securityGroupName);
+	std::string getOnPremiseVolumeRemotePath() const;
+	void setOnPremiseVolumeRemotePath(const std::string &onPremiseVolumeRemotePath);
+	std::string getImageOwnerAlias() const;
+	void setImageOwnerAlias(const std::string &imageOwnerAlias);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getPassword() const;
+	void setPassword(const std::string &password);
+	float getComputeSpotPriceLimit() const;
+	void setComputeSpotPriceLimit(float computeSpotPriceLimit);
+	std::string getOnPremiseVolumeLocalPath() const;
+	void setOnPremiseVolumeLocalPath(const std::string &onPremiseVolumeLocalPath);
+	std::string getRemoteDirectory() const;
+	void setRemoteDirectory(const std::string &remoteDirectory);
+	std::string getComputeSpotStrategy() const;
+	void setComputeSpotStrategy(const std::string &computeSpotStrategy);
+	std::vector<PostInstallScript> getPostInstallScript() const;
+	void setPostInstallScript(const std::vector<PostInstallScript> &postInstallScript);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
+	std::string getDomain() const;
+	void setDomain(const std::string &domain);
+	std::string getName() const;
+	void setName(const std::string &name);
+	std::string getVolumeId() const;
+	void setVolumeId(const std::string &volumeId);
+	std::string getZoneId() const;
+	void setZoneId(const std::string &zoneId);
+	std::string getImageId() const;
+	void setImageId(const std::string &imageId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getEhpcVersion() const;
+	void setEhpcVersion(const std::string &ehpcVersion);
+	std::string getSecurityGroupId() const;
+	void setSecurityGroupId(const std::string &securityGroupId);
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getEcsOrderComputeInstanceType() const;
+	void setEcsOrderComputeInstanceType(const std::string &ecsOrderComputeInstanceType);
+	std::string getJobQueue() const;
+	void setJobQueue(const std::string &jobQueue);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getVolumeType() const;
+	void setVolumeType(const std::string &volumeType);
+	std::string getOnPremiseVolumeMountPoint() const;
+	void setOnPremiseVolumeMountPoint(const std::string &onPremiseVolumeMountPoint);
+	std::string getOnPremiseVolumeProtocol() const;
+	void setOnPremiseVolumeProtocol(const std::string &onPremiseVolumeProtocol);
+	std::string getVolumeProtocol() const;
+	void setVolumeProtocol(const std::string &volumeProtocol);
+	std::string getClientVersion() const;
+	void setClientVersion(const std::string &clientVersion);
+	std::string getOsTag() const;
+	void setOsTag(const std::string &osTag);
+	std::vector<Nodes> getNodes() const;
+	void setNodes(const std::vector<Nodes> &nodes);
+	std::vector<Application> getApplication() const;
+	void setApplication(const std::vector<Application> &application);
+	std::string getVpcId() const;
+	void setVpcId(const std::string &vpcId);
+	std::string getVolumeMountpoint() const;
+	void setVolumeMountpoint(const std::string &volumeMountpoint);
+	bool getSchedulerPreInstall() const;
+	void setSchedulerPreInstall(bool schedulerPreInstall);
+	std::string getLocation() const;
+	void setLocation(const std::string &location);
+
+private:
+	std::string ecsOrderManagerInstanceType_;
+	std::string keyPairName_;
+	bool multiOs_;
+	std::string securityGroupName_;
+	std::string onPremiseVolumeRemotePath_;
+	std::string imageOwnerAlias_;
+	std::string resourceGroupId_;
+	std::string password_;
+	float computeSpotPriceLimit_;
+	std::string onPremiseVolumeLocalPath_;
+	std::string remoteDirectory_;
+	std::string computeSpotStrategy_;
+	std::vector<PostInstallScript> postInstallScript_;
+	std::string vSwitchId_;
+	std::string domain_;
+	std::string name_;
+	std::string volumeId_;
+	std::string zoneId_;
+	std::string imageId_;
+	std::string clientToken_;
+	std::string ehpcVersion_;
+	std::string securityGroupId_;
+	std::string description_;
+	std::string ecsOrderComputeInstanceType_;
+	std::string jobQueue_;
+	std::string accessKeyId_;
+	std::string volumeType_;
+	std::string onPremiseVolumeMountPoint_;
+	std::string onPremiseVolumeProtocol_;
+	std::string volumeProtocol_;
+	std::string clientVersion_;
+	std::string osTag_;
+	std::vector<Nodes> nodes_;
+	std::vector<Application> application_;
+	std::string vpcId_;
+	std::string volumeMountpoint_;
+	bool schedulerPreInstall_;
+	std::string location_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEHYBRIDCLUSTERREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/CreateHybridClusterResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_CREATEHYBRIDCLUSTERRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEHYBRIDCLUSTERRESULT_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 CreateHybridClusterResult : public ServiceResult
+			{
+			public:
+
+
+				CreateHybridClusterResult();
+				explicit CreateHybridClusterResult(const std::string &payload);
+				~CreateHybridClusterResult();
+				std::string getTaskId()const;
+				std::string getClusterId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string taskId_;
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEHYBRIDCLUSTERRESULT_H_

ehpc/include/alibabacloud/ehpc/model/CreateJobFileRequest.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_CREATEJOBFILEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEJOBFILEREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT CreateJobFileRequest : public RpcServiceRequest {
+public:
+	CreateJobFileRequest();
+	~CreateJobFileRequest();
+	std::string getTargetFile() const;
+	void setTargetFile(const std::string &targetFile);
+	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 getContent() const;
+	void setContent(const std::string &content);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+
+private:
+	std::string targetFile_;
+	std::string runasUserPassword_;
+	std::string runasUser_;
+	std::string clusterId_;
+	std::string content_;
+	std::string accessKeyId_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEJOBFILEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/CreateJobFileResult.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_CREATEJOBFILERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_CREATEJOBFILERESULT_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 CreateJobFileResult : public ServiceResult
+			{
+			public:
+
+
+				CreateJobFileResult();
+				explicit CreateJobFileResult(const std::string &payload);
+				~CreateJobFileResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_CREATEJOBFILERESULT_H_

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

@@ -32,16 +32,20 @@ public:
 	~CreateJobTemplateRequest();
 	std::string getStderrRedirectPath() const;
 	void setStderrRedirectPath(const std::string &stderrRedirectPath);
+	std::string getClockTime() const;
+	void setClockTime(const std::string &clockTime);
 	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 getUnzipCmd() const;
+	void setUnzipCmd(const std::string &unzipCmd);
 	std::string getPackagePath() const;
 	void setPackagePath(const std::string &packagePath);
-	std::string getRegionId() const;
-	void setRegionId(const std::string &regionId);
+	std::string getMem() const;
+	void setMem(const std::string &mem);
 	std::string getStdoutRedirectPath() const;
 	void setStdoutRedirectPath(const std::string &stdoutRedirectPath);
 	std::string getVariables() const;
@@ -50,24 +54,47 @@ public:
 	void setRunasUser(const std::string &runasUser);
 	bool getReRunable() const;
 	void setReRunable(bool reRunable);
+	int getThread() const;
+	void setThread(int thread);
 	int getPriority() const;
 	void setPriority(int priority);
+	int getGpu() const;
+	void setGpu(int gpu);
+	bool getWithUnzipCmd() const;
+	void setWithUnzipCmd(bool withUnzipCmd);
+	int getNode() const;
+	void setNode(int node);
+	int getTask() const;
+	void setTask(int task);
+	std::string getInputFileUrl() const;
+	void setInputFileUrl(const std::string &inputFileUrl);
 	std::string getName() const;
 	void setName(const std::string &name);
+	std::string getQueue() const;
+	void setQueue(const std::string &queue);
 
 private:
 	std::string stderrRedirectPath_;
+	std::string clockTime_;
 	std::string commandLine_;
 	std::string accessKeyId_;
 	std::string arrayRequest_;
+	std::string unzipCmd_;
 	std::string packagePath_;
-	std::string regionId_;
+	std::string mem_;
 	std::string stdoutRedirectPath_;
 	std::string variables_;
 	std::string runasUser_;
 	bool reRunable_;
+	int thread_;
 	int priority_;
+	int gpu_;
+	bool withUnzipCmd_;
+	int node_;
+	int task_;
+	std::string inputFileUrl_;
 	std::string name_;
+	std::string queue_;
 };
 } // namespace Model
 } // namespace EHPC

ehpc/include/alibabacloud/ehpc/model/DeleteClusterResult.h

@@ -37,10 +37,12 @@ namespace AlibabaCloud
 				DeleteClusterResult();
 				explicit DeleteClusterResult(const std::string &payload);
 				~DeleteClusterResult();
+				std::string getTaskId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string taskId_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/DeleteContainerAppsRequest.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_DELETECONTAINERAPPSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETECONTAINERAPPSREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT DeleteContainerAppsRequest : public RpcServiceRequest {
+public:
+	struct ContainerApp {
+		std::string id;
+	};
+	DeleteContainerAppsRequest();
+	~DeleteContainerAppsRequest();
+	std::vector<ContainerApp> getContainerApp() const;
+	void setContainerApp(const std::vector<ContainerApp> &containerApp);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+
+private:
+	std::vector<ContainerApp> containerApp_;
+	std::string accessKeyId_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETECONTAINERAPPSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DeleteContainerAppsResult.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_DELETECONTAINERAPPSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETECONTAINERAPPSRESULT_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 DeleteContainerAppsResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteContainerAppsResult();
+				explicit DeleteContainerAppsResult(const std::string &payload);
+				~DeleteContainerAppsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETECONTAINERAPPSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DeleteGWSClusterRequest.h

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

ehpc/include/alibabacloud/ehpc/model/DeleteGWSClusterResult.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_DELETEGWSCLUSTERRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEGWSCLUSTERRESULT_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 DeleteGWSClusterResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteGWSClusterResult();
+				explicit DeleteGWSClusterResult(const std::string &payload);
+				~DeleteGWSClusterResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEGWSCLUSTERRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DeleteGWSInstanceRequest.h

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

ehpc/include/alibabacloud/ehpc/model/DeleteGWSInstanceResult.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_DELETEGWSINSTANCERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEGWSINSTANCERESULT_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 DeleteGWSInstanceResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteGWSInstanceResult();
+				explicit DeleteGWSInstanceResult(const std::string &payload);
+				~DeleteGWSInstanceResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEGWSINSTANCERESULT_H_

ehpc/include/alibabacloud/ehpc/model/DeleteImageRequest.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_DELETEIMAGEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEIMAGEREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT DeleteImageRequest : public RpcServiceRequest {
+public:
+	DeleteImageRequest();
+	~DeleteImageRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getRepository() const;
+	void setRepository(const std::string &repository);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getContainerType() const;
+	void setContainerType(const std::string &containerType);
+	std::string getImageTag() const;
+	void setImageTag(const std::string &imageTag);
+
+private:
+	std::string clusterId_;
+	std::string repository_;
+	std::string accessKeyId_;
+	std::string containerType_;
+	std::string imageTag_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEIMAGEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DeleteImageResult.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_DELETEIMAGERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEIMAGERESULT_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 DeleteImageResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteImageResult();
+				explicit DeleteImageResult(const std::string &payload);
+				~DeleteImageResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEIMAGERESULT_H_

ehpc/include/alibabacloud/ehpc/model/DeleteJobTemplatesRequest.h

@@ -34,13 +34,10 @@ public:
 	void setTemplates(const std::string &templates);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
-	std::string getRegionId() const;
-	void setRegionId(const std::string &regionId);
 
 private:
 	std::string templates_;
 	std::string accessKeyId_;
-	std::string regionId_;
 };
 } // namespace Model
 } // namespace EHPC

ehpc/include/alibabacloud/ehpc/model/DeleteLocalImageRequest.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_DELETELOCALIMAGEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETELOCALIMAGEREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT DeleteLocalImageRequest : public RpcServiceRequest {
+public:
+	DeleteLocalImageRequest();
+	~DeleteLocalImageRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getContainerType() const;
+	void setContainerType(const std::string &containerType);
+	std::string getImageName() const;
+	void setImageName(const std::string &imageName);
+
+private:
+	std::string clusterId_;
+	std::string containerType_;
+	std::string imageName_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETELOCALIMAGEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DeleteLocalImageResult.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_DELETELOCALIMAGERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETELOCALIMAGERESULT_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 DeleteLocalImageResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteLocalImageResult();
+				explicit DeleteLocalImageResult(const std::string &payload);
+				~DeleteLocalImageResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETELOCALIMAGERESULT_H_

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

@@ -37,6 +37,8 @@ public:
 	void setInstance(const std::vector<Instance> &instance);
 	std::string getClusterId() const;
 	void setClusterId(const std::string &clusterId);
+	bool getSync() const;
+	void setSync(bool sync);
 	std::string getAccessKeyId() const;
 	void setAccessKeyId(const std::string &accessKeyId);
 	bool getReleaseInstance() const;
@@ -45,6 +47,7 @@ public:
 private:
 	std::vector<Instance> instance_;
 	std::string clusterId_;
+	bool sync_;
 	std::string accessKeyId_;
 	bool releaseInstance_;
 };

ehpc/include/alibabacloud/ehpc/model/DeleteNodesResult.h

@@ -37,10 +37,12 @@ namespace AlibabaCloud
 				DeleteNodesResult();
 				explicit DeleteNodesResult(const std::string &payload);
 				~DeleteNodesResult();
+				std::string getTaskId()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string taskId_;
 
 			};
 		}

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

ehpc/include/alibabacloud/ehpc/model/DeleteQueueResult.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_DELETEQUEUERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETEQUEUERESULT_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 DeleteQueueResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteQueueResult();
+				explicit DeleteQueueResult(const std::string &payload);
+				~DeleteQueueResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETEQUEUERESULT_H_

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

ehpc/include/alibabacloud/ehpc/model/DeleteSecurityGroupResult.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_DELETESECURITYGROUPRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DELETESECURITYGROUPRESULT_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 DeleteSecurityGroupResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteSecurityGroupResult();
+				explicit DeleteSecurityGroupResult(const std::string &payload);
+				~DeleteSecurityGroupResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DELETESECURITYGROUPRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribeAutoScaleConfigRequest.h

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

ehpc/include/alibabacloud/ehpc/model/DescribeAutoScaleConfigResult.h

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

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

@@ -51,8 +51,14 @@ namespace AlibabaCloud
 							int count;
 							std::string instanceType;
 						};
+						struct ProxyMgr
+						{
+							int count;
+							std::string instanceType;
+						};
 						Compute compute;
 						Login login;
+						ProxyMgr proxyMgr;
 						Manager manager;
 					};
 					struct ApplicationInfo
@@ -61,31 +67,49 @@ namespace AlibabaCloud
 						std::string tag;
 						std::string name;
 					};
-					std::string imageOwnerAlias;
+					struct PostInstallScriptInfo
+					{
+						std::string args;
+						std::string url;
+					};
+					struct OnPremiseInfoItem
+					{
+						std::string type;
+						std::string iP;
+						std::string hostName;
+					};
 					std::string volumeProtocol;
+					std::string imageOwnerAlias;
 					std::string description;
 					std::string clientVersion;
+					std::vector<OnPremiseInfoItem> onPremiseInfo;
 					std::string name;
 					std::string volumeId;
 					std::string volumeType;
+					std::string deployMode;
 					std::string imageId;
 					std::string status;
 					std::string keyPairName;
 					std::string remoteDirectory;
 					std::string sccClusterId;
 					std::vector<ApplicationInfo> applications;
+					std::vector<PostInstallScriptInfo> postInstallScripts;
 					std::string securityGroupId;
 					std::string createTime;
 					std::string vSwitchId;
 					std::string schedulerType;
 					std::string accountType;
+					std::string baseOsTag;
 					std::string volumeMountpoint;
+					std::string imageName;
+					std::string vpcId;
 					EcsInfo ecsInfo;
 					bool haEnable;
 					std::string osTag;
 					std::string ecsChargeType;
 					std::string regionId;
 					std::string id;
+					std::string location;
 				};
 
 

ehpc/include/alibabacloud/ehpc/model/DescribeContainerAppRequest.h

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

ehpc/include/alibabacloud/ehpc/model/DescribeContainerAppResult.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_DESCRIBECONTAINERAPPRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBECONTAINERAPPRESULT_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 DescribeContainerAppResult : public ServiceResult
+			{
+			public:
+				struct ContainerAppInfo
+				{
+					std::string type;
+					std::string repository;
+					std::string imageTag;
+					std::string description;
+					std::string createTime;
+					std::string id;
+					std::string name;
+				};
+
+
+				DescribeContainerAppResult();
+				explicit DescribeContainerAppResult(const std::string &payload);
+				~DescribeContainerAppResult();
+				ContainerAppInfo getContainerAppInfo()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ContainerAppInfo containerAppInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBECONTAINERAPPRESULT_H_

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

ehpc/include/alibabacloud/ehpc/model/DescribeEstackImageResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_DESCRIBEESTACKIMAGERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEESTACKIMAGERESULT_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 DescribeEstackImageResult : public ServiceResult
+			{
+			public:
+				struct ImageListInfo
+				{
+					std::string imageName;
+					int imageSize;
+					std::string recentUpdateTime;
+					std::string imageUrl;
+					std::string imageType;
+				};
+
+
+				DescribeEstackImageResult();
+				explicit DescribeEstackImageResult(const std::string &payload);
+				~DescribeEstackImageResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<ImageListInfo> getImageList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ImageListInfo> imageList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEESTACKIMAGERESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribeGWSClusterPolicyRequest.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_DESCRIBEGWSCLUSTERPOLICYREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERPOLICYREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT DescribeGWSClusterPolicyRequest : public RpcServiceRequest {
+public:
+	DescribeGWSClusterPolicyRequest();
+	~DescribeGWSClusterPolicyRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	bool getAsyncMode() const;
+	void setAsyncMode(bool asyncMode);
+	std::string getTaskId() const;
+	void setTaskId(const std::string &taskId);
+
+private:
+	std::string clusterId_;
+	std::string accessKeyId_;
+	bool asyncMode_;
+	std::string taskId_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERPOLICYREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DescribeGWSClusterPolicyResult.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_DESCRIBEGWSCLUSTERPOLICYRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERPOLICYRESULT_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 DescribeGWSClusterPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeGWSClusterPolicyResult();
+				explicit DescribeGWSClusterPolicyResult(const std::string &payload);
+				~DescribeGWSClusterPolicyResult();
+				std::string getLocalDrive()const;
+				std::string getUsbRedirect()const;
+				std::string getClipboard()const;
+				std::string getWatermark()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string localDrive_;
+				std::string usbRedirect_;
+				std::string clipboard_;
+				std::string watermark_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERPOLICYRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribeGWSClustersRequest.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_DESCRIBEGWSCLUSTERSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERSREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT DescribeGWSClustersRequest : public RpcServiceRequest {
+public:
+	DescribeGWSClustersRequest();
+	~DescribeGWSClustersRequest();
+	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);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+
+private:
+	std::string clusterId_;
+	int pageNumber_;
+	std::string accessKeyId_;
+	int pageSize_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DescribeGWSClustersResult.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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_DESCRIBEGWSCLUSTERSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERSRESULT_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 DescribeGWSClustersResult : public ServiceResult
+			{
+			public:
+				struct ClusterInfo
+				{
+					std::string status;
+					int instanceCount;
+					std::string vpcId;
+					std::string clusterId;
+					std::string createTime;
+				};
+
+
+				DescribeGWSClustersResult();
+				explicit DescribeGWSClustersResult(const std::string &payload);
+				~DescribeGWSClustersResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<ClusterInfo> getClusters()const;
+				std::string getCallerType()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ClusterInfo> clusters_;
+				std::string callerType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSCLUSTERSRESULT_H_

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

ehpc/include/alibabacloud/ehpc/model/DescribeGWSImagesResult.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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_DESCRIBEGWSIMAGESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSIMAGESRESULT_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 DescribeGWSImagesResult : public ServiceResult
+			{
+			public:
+				struct ImageInfo
+				{
+					std::string status;
+					std::string progress;
+					int size;
+					std::string createTime;
+					std::string imageId;
+					std::string imageType;
+					std::string name;
+				};
+
+
+				DescribeGWSImagesResult();
+				explicit DescribeGWSImagesResult(const std::string &payload);
+				~DescribeGWSImagesResult();
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<ImageInfo> getImages()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<ImageInfo> images_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSIMAGESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribeGWSInstancesRequest.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_DESCRIBEGWSINSTANCESREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSINSTANCESREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT DescribeGWSInstancesRequest : public RpcServiceRequest {
+public:
+	DescribeGWSInstancesRequest();
+	~DescribeGWSInstancesRequest();
+	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);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	long getUserUid() const;
+	void setUserUid(long userUid);
+	std::string getUserName() const;
+	void setUserName(const std::string &userName);
+
+private:
+	std::string clusterId_;
+	int pageNumber_;
+	std::string accessKeyId_;
+	std::string instanceId_;
+	int pageSize_;
+	long userUid_;
+	std::string userName_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSINSTANCESREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DescribeGWSInstancesResult.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSINSTANCESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSINSTANCESRESULT_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 DescribeGWSInstancesResult : public ServiceResult
+			{
+			public:
+				struct InstanceInfo
+				{
+					struct AppInfo
+					{
+						std::string appArgs;
+						std::string appPath;
+						std::string appName;
+					};
+					std::string status;
+					std::string userName;
+					std::string instanceId;
+					std::string clusterId;
+					std::string createTime;
+					std::string expireTime;
+					std::string instanceType;
+					std::vector<InstanceInfo::AppInfo> appList;
+					std::string workMode;
+					std::string name;
+				};
+
+
+				DescribeGWSInstancesResult();
+				explicit DescribeGWSInstancesResult(const std::string &payload);
+				~DescribeGWSInstancesResult();
+				std::vector<InstanceInfo> getInstances()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<InstanceInfo> instances_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEGWSINSTANCESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribeImageGatewayConfigRequest.h

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

ehpc/include/alibabacloud/ehpc/model/DescribeImageGatewayConfigResult.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR 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_DESCRIBEIMAGEGATEWAYCONFIGRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGEGATEWAYCONFIGRESULT_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 DescribeImageGatewayConfigResult : public ServiceResult
+			{
+			public:
+				struct Imagegw
+				{
+					struct LocationInfo
+					{
+						std::string remoteType;
+						std::string authentication;
+						std::string uRL;
+						std::string location;
+					};
+					std::string defaultImageLocation;
+					long pullUpdateTimeout;
+					std::string mongoDBURI;
+					std::vector<LocationInfo> locations;
+					std::string imageExpirationTimeout;
+					std::string updateDateTime;
+				};
+
+
+				DescribeImageGatewayConfigResult();
+				explicit DescribeImageGatewayConfigResult(const std::string &payload);
+				~DescribeImageGatewayConfigResult();
+				Imagegw getImagegw()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Imagegw imagegw_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGEGATEWAYCONFIGRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribeImagePriceRequest.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_DESCRIBEIMAGEPRICEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGEPRICEREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT DescribeImagePriceRequest : public RpcServiceRequest {
+public:
+	DescribeImagePriceRequest();
+	~DescribeImagePriceRequest();
+	int getPeriod() const;
+	void setPeriod(int period);
+	int getAmount() const;
+	void setAmount(int amount);
+	std::string getImageId() const;
+	void setImageId(const std::string &imageId);
+	std::string getSkuCode() const;
+	void setSkuCode(const std::string &skuCode);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getPriceUnit() const;
+	void setPriceUnit(const std::string &priceUnit);
+	std::string getOrderType() const;
+	void setOrderType(const std::string &orderType);
+
+private:
+	int period_;
+	int amount_;
+	std::string imageId_;
+	std::string skuCode_;
+	std::string accessKeyId_;
+	std::string priceUnit_;
+	std::string orderType_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGEPRICEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DescribeImagePriceResult.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_DESCRIBEIMAGEPRICERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGEPRICERESULT_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 DescribeImagePriceResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeImagePriceResult();
+				explicit DescribeImagePriceResult(const std::string &payload);
+				~DescribeImagePriceResult();
+				float getOriginalPrice()const;
+				int getAmount()const;
+				float getDiscountPrice()const;
+				std::string getImageId()const;
+				float getTradePrice()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				float originalPrice_;
+				int amount_;
+				float discountPrice_;
+				std::string imageId_;
+				float tradePrice_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGEPRICERESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribeImageRequest.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_DESCRIBEIMAGEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGEREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT DescribeImageRequest : public RpcServiceRequest {
+public:
+	DescribeImageRequest();
+	~DescribeImageRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getRepository() const;
+	void setRepository(const std::string &repository);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getContainerType() const;
+	void setContainerType(const std::string &containerType);
+	std::string getImageTag() const;
+	void setImageTag(const std::string &imageTag);
+
+private:
+	std::string clusterId_;
+	std::string repository_;
+	std::string accessKeyId_;
+	std::string containerType_;
+	std::string imageTag_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DescribeImageResult.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_DESCRIBEIMAGERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGERESULT_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 DescribeImageResult : public ServiceResult
+			{
+			public:
+				struct ImageInfo
+				{
+					std::string status;
+					std::string type;
+					std::string repository;
+					std::string imageId;
+					std::string updateDateTime;
+					std::string tag;
+					std::string system;
+				};
+
+
+				DescribeImageResult();
+				explicit DescribeImageResult(const std::string &payload);
+				~DescribeImageResult();
+				ImageInfo getImageInfo()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				ImageInfo imageInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEIMAGERESULT_H_

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

ehpc/include/alibabacloud/ehpc/model/DescribeJobResult.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_DESCRIBEJOBRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEJOBRESULT_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 DescribeJobResult : public ServiceResult
+			{
+			public:
+				struct Message
+				{
+					std::string jobInfo;
+				};
+
+
+				DescribeJobResult();
+				explicit DescribeJobResult(const std::string &payload);
+				~DescribeJobResult();
+				Message getMessage()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Message message_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEJOBRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribeNFSClientStatusRequest.h

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

ehpc/include/alibabacloud/ehpc/model/DescribeNFSClientStatusResult.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_DESCRIBENFSCLIENTSTATUSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBENFSCLIENTSTATUSRESULT_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 DescribeNFSClientStatusResult : public ServiceResult
+			{
+			public:
+				struct Result
+				{
+					std::string output;
+					int exitCode;
+					std::string invokeRecordStatus;
+				};
+
+
+				DescribeNFSClientStatusResult();
+				explicit DescribeNFSClientStatusResult(const std::string &payload);
+				~DescribeNFSClientStatusResult();
+				std::string getStatus()const;
+				Result getResult()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				Result result_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBENFSCLIENTSTATUSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/DescribePriceRequest.h

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_DESCRIBEPRICEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEPRICEREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT DescribePriceRequest : public RpcServiceRequest {
+public:
+	struct Commodities {
+		int amount;
+		int period;
+		std::string nodeType;
+		struct DataDisks {
+			int size;
+			bool encrypted;
+			std::string performanceLevel;
+			std::string category;
+			bool deleteWithInstance;
+		};
+		std::vector<DataDisks> dataDisks;
+		std::string systemDiskCategory;
+		std::string internetChargeType;
+		std::string systemDiskPerformanceLevel;
+		int systemDiskSize;
+		int internetMaxBandWidthOut;
+		std::string instanceType;
+		std::string networkType;
+	};
+	DescribePriceRequest();
+	~DescribePriceRequest();
+	std::vector<Commodities> getCommodities() const;
+	void setCommodities(const std::vector<Commodities> &commodities);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getPriceUnit() const;
+	void setPriceUnit(const std::string &priceUnit);
+	std::string getChargeType() const;
+	void setChargeType(const std::string &chargeType);
+	std::string getOrderType() const;
+	void setOrderType(const std::string &orderType);
+
+private:
+	std::vector<Commodities> commodities_;
+	std::string accessKeyId_;
+	std::string priceUnit_;
+	std::string chargeType_;
+	std::string orderType_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEPRICEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/DescribePriceResult.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_DESCRIBEPRICERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_DESCRIBEPRICERESULT_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 DescribePriceResult : public ServiceResult
+			{
+			public:
+				struct PriceInfo
+				{
+					float originalPrice;
+					std::string nodeType;
+					std::string currency;
+					float tradePrice;
+				};
+
+
+				DescribePriceResult();
+				explicit DescribePriceResult(const std::string &payload);
+				~DescribePriceResult();
+				std::vector<PriceInfo> getPrices()const;
+				float getTotalTradePrice()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<PriceInfo> prices_;
+				float totalTradePrice_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_DESCRIBEPRICERESULT_H_

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

@@ -32,16 +32,20 @@ public:
 	~EditJobTemplateRequest();
 	std::string getStderrRedirectPath() const;
 	void setStderrRedirectPath(const std::string &stderrRedirectPath);
+	std::string getClockTime() const;
+	void setClockTime(const std::string &clockTime);
 	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 getUnzipCmd() const;
+	void setUnzipCmd(const std::string &unzipCmd);
 	std::string getPackagePath() const;
 	void setPackagePath(const std::string &packagePath);
-	std::string getRegionId() const;
-	void setRegionId(const std::string &regionId);
+	std::string getMem() const;
+	void setMem(const std::string &mem);
 	std::string getStdoutRedirectPath() const;
 	void setStdoutRedirectPath(const std::string &stdoutRedirectPath);
 	std::string getVariables() const;
@@ -50,27 +54,50 @@ public:
 	void setRunasUser(const std::string &runasUser);
 	bool getReRunable() const;
 	void setReRunable(bool reRunable);
+	int getThread() const;
+	void setThread(int thread);
 	std::string getTemplateId() const;
 	void setTemplateId(const std::string &templateId);
 	int getPriority() const;
 	void setPriority(int priority);
+	int getGpu() const;
+	void setGpu(int gpu);
+	bool getWithUnzipCmd() const;
+	void setWithUnzipCmd(bool withUnzipCmd);
+	int getNode() const;
+	void setNode(int node);
+	int getTask() const;
+	void setTask(int task);
+	std::string getInputFileUrl() const;
+	void setInputFileUrl(const std::string &inputFileUrl);
 	std::string getName() const;
 	void setName(const std::string &name);
+	std::string getQueue() const;
+	void setQueue(const std::string &queue);
 
 private:
 	std::string stderrRedirectPath_;
+	std::string clockTime_;
 	std::string commandLine_;
 	std::string accessKeyId_;
 	std::string arrayRequest_;
+	std::string unzipCmd_;
 	std::string packagePath_;
-	std::string regionId_;
+	std::string mem_;
 	std::string stdoutRedirectPath_;
 	std::string variables_;
 	std::string runasUser_;
 	bool reRunable_;
+	int thread_;
 	std::string templateId_;
 	int priority_;
+	int gpu_;
+	bool withUnzipCmd_;
+	int node_;
+	int task_;
+	std::string inputFileUrl_;
 	std::string name_;
+	std::string queue_;
 };
 } // namespace Model
 } // namespace EHPC

ehpc/include/alibabacloud/ehpc/model/GetAccountingReportRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETACCOUNTINGREPORTREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETACCOUNTINGREPORTREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT GetAccountingReportRequest : public RpcServiceRequest {
+public:
+	GetAccountingReportRequest();
+	~GetAccountingReportRequest();
+	std::string getReportType() const;
+	void setReportType(const std::string &reportType);
+	int getEndTime() const;
+	void setEndTime(int endTime);
+	std::string getFilterValue() const;
+	void setFilterValue(const std::string &filterValue);
+	std::string getDim() const;
+	void setDim(const std::string &dim);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	int getStartTime() const;
+	void setStartTime(int startTime);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getJobId() const;
+	void setJobId(const std::string &jobId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+
+private:
+	std::string reportType_;
+	int endTime_;
+	std::string filterValue_;
+	std::string dim_;
+	std::string clusterId_;
+	int startTime_;
+	int pageNumber_;
+	std::string accessKeyId_;
+	std::string jobId_;
+	int pageSize_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETACCOUNTINGREPORTREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetAccountingReportResult.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_GETACCOUNTINGREPORTRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETACCOUNTINGREPORTRESULT_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 GetAccountingReportResult : public ServiceResult
+			{
+			public:
+
+
+				GetAccountingReportResult();
+				explicit GetAccountingReportResult(const std::string &payload);
+				~GetAccountingReportResult();
+				std::string getMetrics()const;
+				int getTotalCount()const;
+				int getPageSize()const;
+				int getPageNumber()const;
+				std::vector<std::string> getData()const;
+				int getTotalCoreTime()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string metrics_;
+				int totalCount_;
+				int pageSize_;
+				int pageNumber_;
+				std::vector<std::string> data_;
+				int totalCoreTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETACCOUNTINGREPORTRESULT_H_

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

@@ -32,6 +32,46 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_EHPC_EXPORT GetAutoScaleConfigResult : public ServiceResult
 			{
 			public:
+				struct QueueInfo
+				{
+					struct InstanceTypeInfo
+					{
+						std::string zoneId;
+						std::string vSwitchId;
+						std::string hostNamePrefix;
+						float spotPriceLimit;
+						std::string instanceType;
+						std::string spotStrategy;
+					};
+					struct DataDisksInfo
+					{
+						std::string dataDiskPerformanceLevel;
+						std::string dataDiskKMSKeyId;
+						bool dataDiskDeleteWithInstance;
+						bool dataDiskEncrypted;
+						int dataDiskSize;
+						std::string dataDiskCategory;
+					};
+					std::string hostNameSuffix;
+					int minNodesInQueue;
+					int maxNodesInQueue;
+					std::vector<QueueInfo::DataDisksInfo> dataDisks;
+					bool enableAutoGrow;
+					std::string resourceGroupId;
+					std::string queueImageId;
+					int systemDiskSize;
+					std::string systemDiskLevel;
+					long minNodesPerCycle;
+					long maxNodesPerCycle;
+					bool enableAutoShrink;
+					std::string systemDiskCategory;
+					std::string hostNamePrefix;
+					float spotPriceLimit;
+					std::vector<QueueInfo::InstanceTypeInfo> instanceTypes;
+					std::string instanceType;
+					std::string queueName;
+					std::string spotStrategy;
+				};
 
 
 				GetAutoScaleConfigResult();
@@ -48,8 +88,12 @@ namespace AlibabaCloud
 				int getGrowIntervalInMinutes()const;
 				std::string getUid()const;
 				int getGrowTimeoutInMinutes()const;
+				std::string getImageId()const;
 				int getShrinkIntervalInMinutes()const;
+				float getSpotPriceLimit()const;
+				std::vector<QueueInfo> getQueues()const;
 				std::string getExcludeNodes()const;
+				std::string getSpotStrategy()const;
 
 			protected:
 				void parse(const std::string &payload);
@@ -65,8 +109,12 @@ namespace AlibabaCloud
 				int growIntervalInMinutes_;
 				std::string uid_;
 				int growTimeoutInMinutes_;
+				std::string imageId_;
 				int shrinkIntervalInMinutes_;
+				float spotPriceLimit_;
+				std::vector<QueueInfo> queues_;
 				std::string excludeNodes_;
+				std::string spotStrategy_;
 
 			};
 		}

ehpc/include/alibabacloud/ehpc/model/GetCloudMetricLogsRequest.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICLOGSREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICLOGSREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT GetCloudMetricLogsRequest : public RpcServiceRequest {
+public:
+	GetCloudMetricLogsRequest();
+	~GetCloudMetricLogsRequest();
+	std::string getMetricScope() const;
+	void setMetricScope(const std::string &metricScope);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	int getAggregationInterval() const;
+	void setAggregationInterval(int aggregationInterval);
+	bool getReverse() const;
+	void setReverse(bool reverse);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getAggregationType() const;
+	void setAggregationType(const std::string &aggregationType);
+	std::string getFilter() const;
+	void setFilter(const std::string &filter);
+	std::string getMetricCategories() const;
+	void setMetricCategories(const std::string &metricCategories);
+	int getFrom() const;
+	void setFrom(int from);
+	int getTo() const;
+	void setTo(int to);
+
+private:
+	std::string metricScope_;
+	std::string clusterId_;
+	int aggregationInterval_;
+	bool reverse_;
+	std::string accessKeyId_;
+	std::string aggregationType_;
+	std::string filter_;
+	std::string metricCategories_;
+	int from_;
+	int to_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICLOGSREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetCloudMetricLogsResult.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_GETCLOUDMETRICLOGSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICLOGSRESULT_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 GetCloudMetricLogsResult : public ServiceResult
+			{
+			public:
+				struct MetricLog
+				{
+					std::string instanceId;
+					std::string diskDevice;
+					std::string hostname;
+					std::string networkInterface;
+					int time;
+					std::string metricData;
+				};
+
+
+				GetCloudMetricLogsResult();
+				explicit GetCloudMetricLogsResult(const std::string &payload);
+				~GetCloudMetricLogsResult();
+				std::vector<MetricLog> getMetricLogs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<MetricLog> metricLogs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICLOGSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/GetCloudMetricProfilingRequest.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_GETCLOUDMETRICPROFILINGREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICPROFILINGREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT GetCloudMetricProfilingRequest : public RpcServiceRequest {
+public:
+	GetCloudMetricProfilingRequest();
+	~GetCloudMetricProfilingRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getProfilingId() const;
+	void setProfilingId(const std::string &profilingId);
+
+private:
+	std::string clusterId_;
+	std::string accessKeyId_;
+	std::string regionId_;
+	std::string profilingId_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICPROFILINGREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetCloudMetricProfilingResult.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_GETCLOUDMETRICPROFILINGRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICPROFILINGRESULT_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 GetCloudMetricProfilingResult : public ServiceResult
+			{
+			public:
+				struct SvgInfo
+				{
+					std::string type;
+					int size;
+					std::string url;
+					std::string name;
+				};
+
+
+				GetCloudMetricProfilingResult();
+				explicit GetCloudMetricProfilingResult(const std::string &payload);
+				~GetCloudMetricProfilingResult();
+				std::vector<SvgInfo> getSvgUrls()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SvgInfo> svgUrls_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETCLOUDMETRICPROFILINGRESULT_H_

ehpc/include/alibabacloud/ehpc/model/GetClusterVolumesRequest.h

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

ehpc/include/alibabacloud/ehpc/model/GetClusterVolumesResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETCLUSTERVOLUMESRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETCLUSTERVOLUMESRESULT_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 GetClusterVolumesResult : public ServiceResult
+			{
+			public:
+				struct VolumeInfo
+				{
+					struct RoleInfo
+					{
+						std::string name;
+					};
+					std::string volumeProtocol;
+					std::string volumeId;
+					std::string remoteDirectory;
+					std::string localDirectory;
+					std::string volumeType;
+					std::string jobQueue;
+					bool mustKeep;
+					std::vector<VolumeInfo::RoleInfo> roles;
+					std::string volumeMountpoint;
+					std::string location;
+				};
+
+
+				GetClusterVolumesResult();
+				explicit GetClusterVolumesResult(const std::string &payload);
+				~GetClusterVolumesResult();
+				std::vector<VolumeInfo> getVolumes()const;
+				std::string getRegionId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<VolumeInfo> volumes_;
+				std::string regionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETCLUSTERVOLUMESRESULT_H_

ehpc/include/alibabacloud/ehpc/model/GetCommonImageRequest.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_GETCOMMONIMAGEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETCOMMONIMAGEREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT GetCommonImageRequest : public RpcServiceRequest {
+public:
+	GetCommonImageRequest();
+	~GetCommonImageRequest();
+	std::string getContainType() const;
+	void setContainType(const std::string &containType);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getImageName() const;
+	void setImageName(const std::string &imageName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string containType_;
+	std::string clusterId_;
+	std::string imageName_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETCOMMONIMAGEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetCommonImageResult.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_GETCOMMONIMAGERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETCOMMONIMAGERESULT_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 GetCommonImageResult : public ServiceResult
+			{
+			public:
+
+
+				GetCommonImageResult();
+				explicit GetCommonImageResult(const std::string &payload);
+				~GetCommonImageResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETCOMMONIMAGERESULT_H_

ehpc/include/alibabacloud/ehpc/model/GetGWSConnectTicketRequest.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_GETGWSCONNECTTICKETREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETGWSCONNECTTICKETREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT GetGWSConnectTicketRequest : public RpcServiceRequest {
+public:
+	GetGWSConnectTicketRequest();
+	~GetGWSConnectTicketRequest();
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getAppName() const;
+	void setAppName(const std::string &appName);
+
+private:
+	std::string accessKeyId_;
+	std::string instanceId_;
+	std::string appName_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETGWSCONNECTTICKETREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetGWSConnectTicketResult.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_GETGWSCONNECTTICKETRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETGWSCONNECTTICKETRESULT_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 GetGWSConnectTicketResult : public ServiceResult
+			{
+			public:
+
+
+				GetGWSConnectTicketResult();
+				explicit GetGWSConnectTicketResult(const std::string &payload);
+				~GetGWSConnectTicketResult();
+				std::string getTicket()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string ticket_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETGWSCONNECTTICKETRESULT_H_

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

ehpc/include/alibabacloud/ehpc/model/GetHybridClusterConfigResult.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_GETHYBRIDCLUSTERCONFIGRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETHYBRIDCLUSTERCONFIGRESULT_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 GetHybridClusterConfigResult : public ServiceResult
+			{
+			public:
+
+
+				GetHybridClusterConfigResult();
+				explicit GetHybridClusterConfigResult(const std::string &payload);
+				~GetHybridClusterConfigResult();
+				std::string getClusterConfig()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string clusterConfig_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETHYBRIDCLUSTERCONFIGRESULT_H_

ehpc/include/alibabacloud/ehpc/model/GetIfEcsTypeSupportHtConfigRequest.h

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

ehpc/include/alibabacloud/ehpc/model/GetIfEcsTypeSupportHtConfigResult.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_EHPC_MODEL_GETIFECSTYPESUPPORTHTCONFIGRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETIFECSTYPESUPPORTHTCONFIGRESULT_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 GetIfEcsTypeSupportHtConfigResult : public ServiceResult
+			{
+			public:
+
+
+				GetIfEcsTypeSupportHtConfigResult();
+				explicit GetIfEcsTypeSupportHtConfigResult(const std::string &payload);
+				~GetIfEcsTypeSupportHtConfigResult();
+				bool getDefaultHtEnabled()const;
+				bool getSupportHtConfig()const;
+				std::string getInstanceType()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool defaultHtEnabled_;
+				bool supportHtConfig_;
+				std::string instanceType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETIFECSTYPESUPPORTHTCONFIGRESULT_H_

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

ehpc/include/alibabacloud/ehpc/model/GetPostScriptsResult.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_GETPOSTSCRIPTSRESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETPOSTSCRIPTSRESULT_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 GetPostScriptsResult : public ServiceResult
+			{
+			public:
+				struct PostInstallScriptsItem
+				{
+					std::string args;
+					std::string url;
+				};
+
+
+				GetPostScriptsResult();
+				explicit GetPostScriptsResult(const std::string &payload);
+				~GetPostScriptsResult();
+				std::vector<PostInstallScriptsItem> getPostInstallScripts()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<PostInstallScriptsItem> postInstallScripts_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETPOSTSCRIPTSRESULT_H_

ehpc/include/alibabacloud/ehpc/model/GetSchedulerInfoRequest.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_GETSCHEDULERINFOREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETSCHEDULERINFOREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT GetSchedulerInfoRequest : public RpcServiceRequest {
+public:
+	struct Scheduler {
+		std::string schedName;
+	};
+	GetSchedulerInfoRequest();
+	~GetSchedulerInfoRequest();
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getAccessKeyId() const;
+	void setAccessKeyId(const std::string &accessKeyId);
+	std::vector<Scheduler> getScheduler() const;
+	void setScheduler(const std::vector<Scheduler> &scheduler);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string clusterId_;
+	std::string accessKeyId_;
+	std::vector<Scheduler> scheduler_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETSCHEDULERINFOREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetSchedulerInfoResult.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_GETSCHEDULERINFORESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETSCHEDULERINFORESULT_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 GetSchedulerInfoResult : public ServiceResult
+			{
+			public:
+				struct SchedInfoItem
+				{
+					std::string configuration;
+					std::string schedName;
+				};
+
+
+				GetSchedulerInfoResult();
+				explicit GetSchedulerInfoResult(const std::string &payload);
+				~GetSchedulerInfoResult();
+				std::vector<SchedInfoItem> getSchedInfo()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<SchedInfoItem> schedInfo_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETSCHEDULERINFORESULT_H_

ehpc/include/alibabacloud/ehpc/model/GetUserImageRequest.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_GETUSERIMAGEREQUEST_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETUSERIMAGEREQUEST_H_
+
+#include <alibabacloud/ehpc/EHPCExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace EHPC {
+namespace Model {
+class ALIBABACLOUD_EHPC_EXPORT GetUserImageRequest : public RpcServiceRequest {
+public:
+	GetUserImageRequest();
+	~GetUserImageRequest();
+	std::string getOSSBucket() const;
+	void setOSSBucket(const std::string &oSSBucket);
+	std::string getOSSEndPoint() const;
+	void setOSSEndPoint(const std::string &oSSEndPoint);
+	std::string getClusterId() const;
+	void setClusterId(const std::string &clusterId);
+	std::string getContainerType() const;
+	void setContainerType(const std::string &containerType);
+	std::string getImagePath() const;
+	void setImagePath(const std::string &imagePath);
+	std::string getImageName() const;
+	void setImageName(const std::string &imageName);
+
+private:
+	std::string oSSBucket_;
+	std::string oSSEndPoint_;
+	std::string clusterId_;
+	std::string containerType_;
+	std::string imagePath_;
+	std::string imageName_;
+};
+} // namespace Model
+} // namespace EHPC
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETUSERIMAGEREQUEST_H_

ehpc/include/alibabacloud/ehpc/model/GetUserImageResult.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_GETUSERIMAGERESULT_H_
+#define ALIBABACLOUD_EHPC_MODEL_GETUSERIMAGERESULT_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 GetUserImageResult : public ServiceResult
+			{
+			public:
+
+
+				GetUserImageResult();
+				explicit GetUserImageResult(const std::string &payload);
+				~GetUserImageResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_EHPC_MODEL_GETUSERIMAGERESULT_H_