Support desktop group auto scale.

VERSION

@@ -1 +1 @@
-1.36.1551
+1.36.1552

ecd/CMakeLists.txt

@@ -23,8 +23,14 @@ set(ecd_public_header
 set(ecd_public_header_model 
 	include/alibabacloud/ecd/model/ActivateOfficeSiteRequest.h
 	include/alibabacloud/ecd/model/ActivateOfficeSiteResult.h
+	include/alibabacloud/ecd/model/AddDevicesRequest.h
+	include/alibabacloud/ecd/model/AddDevicesResult.h
+	include/alibabacloud/ecd/model/AddFilePermissionRequest.h
+	include/alibabacloud/ecd/model/AddFilePermissionResult.h
 	include/alibabacloud/ecd/model/AddUserToDesktopGroupRequest.h
 	include/alibabacloud/ecd/model/AddUserToDesktopGroupResult.h
+	include/alibabacloud/ecd/model/ApplyAutoSnapshotPolicyRequest.h
+	include/alibabacloud/ecd/model/ApplyAutoSnapshotPolicyResult.h
 	include/alibabacloud/ecd/model/ApplyCoordinatePrivilegeRequest.h
 	include/alibabacloud/ecd/model/ApplyCoordinatePrivilegeResult.h
 	include/alibabacloud/ecd/model/ApplyCoordinationForMonitoringRequest.h
@@ -35,16 +41,26 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/AssociateNetworkPackageResult.h
 	include/alibabacloud/ecd/model/AttachCenRequest.h
 	include/alibabacloud/ecd/model/AttachCenResult.h
+	include/alibabacloud/ecd/model/AttachEndUserRequest.h
+	include/alibabacloud/ecd/model/AttachEndUserResult.h
+	include/alibabacloud/ecd/model/CancelAutoSnapshotPolicyRequest.h
+	include/alibabacloud/ecd/model/CancelAutoSnapshotPolicyResult.h
+	include/alibabacloud/ecd/model/CancelCdsFileShareLinkRequest.h
+	include/alibabacloud/ecd/model/CancelCdsFileShareLinkResult.h
 	include/alibabacloud/ecd/model/CancelCoordinationForMonitoringRequest.h
 	include/alibabacloud/ecd/model/CancelCoordinationForMonitoringResult.h
 	include/alibabacloud/ecd/model/CancelCopyImageRequest.h
 	include/alibabacloud/ecd/model/CancelCopyImageResult.h
 	include/alibabacloud/ecd/model/ClonePolicyGroupRequest.h
 	include/alibabacloud/ecd/model/ClonePolicyGroupResult.h
+	include/alibabacloud/ecd/model/CompleteCdsFileRequest.h
+	include/alibabacloud/ecd/model/CompleteCdsFileResult.h
 	include/alibabacloud/ecd/model/ConfigADConnectorTrustRequest.h
 	include/alibabacloud/ecd/model/ConfigADConnectorTrustResult.h
 	include/alibabacloud/ecd/model/ConfigADConnectorUserRequest.h
 	include/alibabacloud/ecd/model/ConfigADConnectorUserResult.h
+	include/alibabacloud/ecd/model/CopyCdsFileRequest.h
+	include/alibabacloud/ecd/model/CopyCdsFileResult.h
 	include/alibabacloud/ecd/model/CopyImageRequest.h
 	include/alibabacloud/ecd/model/CopyImageResult.h
 	include/alibabacloud/ecd/model/CreateADConnectorDirectoryRequest.h
@@ -53,16 +69,20 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/CreateADConnectorOfficeSiteResult.h
 	include/alibabacloud/ecd/model/CreateAndBindNasFileSystemRequest.h
 	include/alibabacloud/ecd/model/CreateAndBindNasFileSystemResult.h
+	include/alibabacloud/ecd/model/CreateAutoSnapshotPolicyRequest.h
+	include/alibabacloud/ecd/model/CreateAutoSnapshotPolicyResult.h
 	include/alibabacloud/ecd/model/CreateBundleRequest.h
 	include/alibabacloud/ecd/model/CreateBundleResult.h
+	include/alibabacloud/ecd/model/CreateCdsFileRequest.h
+	include/alibabacloud/ecd/model/CreateCdsFileResult.h
+	include/alibabacloud/ecd/model/CreateCdsFileShareLinkRequest.h
+	include/alibabacloud/ecd/model/CreateCdsFileShareLinkResult.h
 	include/alibabacloud/ecd/model/CreateDesktopGroupRequest.h
 	include/alibabacloud/ecd/model/CreateDesktopGroupResult.h
 	include/alibabacloud/ecd/model/CreateDesktopsRequest.h
 	include/alibabacloud/ecd/model/CreateDesktopsResult.h
 	include/alibabacloud/ecd/model/CreateDiskEncryptionServiceRequest.h
 	include/alibabacloud/ecd/model/CreateDiskEncryptionServiceResult.h
-	include/alibabacloud/ecd/model/CreateDriveRequest.h
-	include/alibabacloud/ecd/model/CreateDriveResult.h
 	include/alibabacloud/ecd/model/CreateImageRequest.h
 	include/alibabacloud/ecd/model/CreateImageResult.h
 	include/alibabacloud/ecd/model/CreateNASFileSystemRequest.h
@@ -77,18 +97,24 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/CreateSimpleOfficeSiteResult.h
 	include/alibabacloud/ecd/model/CreateSnapshotRequest.h
 	include/alibabacloud/ecd/model/CreateSnapshotResult.h
+	include/alibabacloud/ecd/model/DeleteAutoSnapshotPolicyRequest.h
+	include/alibabacloud/ecd/model/DeleteAutoSnapshotPolicyResult.h
 	include/alibabacloud/ecd/model/DeleteBundlesRequest.h
 	include/alibabacloud/ecd/model/DeleteBundlesResult.h
+	include/alibabacloud/ecd/model/DeleteCdsFileRequest.h
+	include/alibabacloud/ecd/model/DeleteCdsFileResult.h
+	include/alibabacloud/ecd/model/DeleteCloudDriveGroupsRequest.h
+	include/alibabacloud/ecd/model/DeleteCloudDriveGroupsResult.h
 	include/alibabacloud/ecd/model/DeleteCloudDriveUsersRequest.h
 	include/alibabacloud/ecd/model/DeleteCloudDriveUsersResult.h
 	include/alibabacloud/ecd/model/DeleteDesktopGroupRequest.h
 	include/alibabacloud/ecd/model/DeleteDesktopGroupResult.h
 	include/alibabacloud/ecd/model/DeleteDesktopsRequest.h
 	include/alibabacloud/ecd/model/DeleteDesktopsResult.h
+	include/alibabacloud/ecd/model/DeleteDevicesRequest.h
+	include/alibabacloud/ecd/model/DeleteDevicesResult.h
 	include/alibabacloud/ecd/model/DeleteDirectoriesRequest.h
 	include/alibabacloud/ecd/model/DeleteDirectoriesResult.h
-	include/alibabacloud/ecd/model/DeleteDriveRequest.h
-	include/alibabacloud/ecd/model/DeleteDriveResult.h
 	include/alibabacloud/ecd/model/DeleteImagesRequest.h
 	include/alibabacloud/ecd/model/DeleteImagesResult.h
 	include/alibabacloud/ecd/model/DeleteNASFileSystemsRequest.h
@@ -105,12 +131,18 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/DeleteVirtualMFADeviceResult.h
 	include/alibabacloud/ecd/model/DescribeAlarmEventStackInfoRequest.h
 	include/alibabacloud/ecd/model/DescribeAlarmEventStackInfoResult.h
+	include/alibabacloud/ecd/model/DescribeAutoSnapshotPolicyRequest.h
+	include/alibabacloud/ecd/model/DescribeAutoSnapshotPolicyResult.h
 	include/alibabacloud/ecd/model/DescribeBundlesRequest.h
 	include/alibabacloud/ecd/model/DescribeBundlesResult.h
+	include/alibabacloud/ecd/model/DescribeCdsFileShareLinksRequest.h
+	include/alibabacloud/ecd/model/DescribeCdsFileShareLinksResult.h
 	include/alibabacloud/ecd/model/DescribeCensRequest.h
 	include/alibabacloud/ecd/model/DescribeCensResult.h
 	include/alibabacloud/ecd/model/DescribeClientEventsRequest.h
 	include/alibabacloud/ecd/model/DescribeClientEventsResult.h
+	include/alibabacloud/ecd/model/DescribeCloudDriveGroupsRequest.h
+	include/alibabacloud/ecd/model/DescribeCloudDriveGroupsResult.h
 	include/alibabacloud/ecd/model/DescribeCloudDrivePermissionsRequest.h
 	include/alibabacloud/ecd/model/DescribeCloudDrivePermissionsResult.h
 	include/alibabacloud/ecd/model/DescribeCustomizedListHeadersRequest.h
@@ -125,10 +157,10 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/DescribeDesktopsResult.h
 	include/alibabacloud/ecd/model/DescribeDesktopsInGroupRequest.h
 	include/alibabacloud/ecd/model/DescribeDesktopsInGroupResult.h
+	include/alibabacloud/ecd/model/DescribeDevicesRequest.h
+	include/alibabacloud/ecd/model/DescribeDevicesResult.h
 	include/alibabacloud/ecd/model/DescribeDirectoriesRequest.h
 	include/alibabacloud/ecd/model/DescribeDirectoriesResult.h
-	include/alibabacloud/ecd/model/DescribeDrivesRequest.h
-	include/alibabacloud/ecd/model/DescribeDrivesResult.h
 	include/alibabacloud/ecd/model/DescribeFlowMetricRequest.h
 	include/alibabacloud/ecd/model/DescribeFlowMetricResult.h
 	include/alibabacloud/ecd/model/DescribeFlowStatisticRequest.h
@@ -177,6 +209,8 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/DescribeSuspEventsResult.h
 	include/alibabacloud/ecd/model/DescribeUserConnectionRecordsRequest.h
 	include/alibabacloud/ecd/model/DescribeUserConnectionRecordsResult.h
+	include/alibabacloud/ecd/model/DescribeUserProfilePathRulesRequest.h
+	include/alibabacloud/ecd/model/DescribeUserProfilePathRulesResult.h
 	include/alibabacloud/ecd/model/DescribeUsersInGroupRequest.h
 	include/alibabacloud/ecd/model/DescribeUsersInGroupResult.h
 	include/alibabacloud/ecd/model/DescribeUsersPasswordRequest.h
@@ -193,6 +227,8 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/DescribeZonesResult.h
 	include/alibabacloud/ecd/model/DetachCenRequest.h
 	include/alibabacloud/ecd/model/DetachCenResult.h
+	include/alibabacloud/ecd/model/DetachEndUserRequest.h
+	include/alibabacloud/ecd/model/DetachEndUserResult.h
 	include/alibabacloud/ecd/model/DisableDesktopsInGroupRequest.h
 	include/alibabacloud/ecd/model/DisableDesktopsInGroupResult.h
 	include/alibabacloud/ecd/model/DissociateNetworkPackageRequest.h
@@ -213,8 +249,14 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/GetSpMetadataResult.h
 	include/alibabacloud/ecd/model/HandleSecurityEventsRequest.h
 	include/alibabacloud/ecd/model/HandleSecurityEventsResult.h
+	include/alibabacloud/ecd/model/HibernateDesktopsRequest.h
+	include/alibabacloud/ecd/model/HibernateDesktopsResult.h
+	include/alibabacloud/ecd/model/ListCdsFilesRequest.h
+	include/alibabacloud/ecd/model/ListCdsFilesResult.h
 	include/alibabacloud/ecd/model/ListDirectoryUsersRequest.h
 	include/alibabacloud/ecd/model/ListDirectoryUsersResult.h
+	include/alibabacloud/ecd/model/ListFilePermissionRequest.h
+	include/alibabacloud/ecd/model/ListFilePermissionResult.h
 	include/alibabacloud/ecd/model/ListOfficeSiteOverviewRequest.h
 	include/alibabacloud/ecd/model/ListOfficeSiteOverviewResult.h
 	include/alibabacloud/ecd/model/ListOfficeSiteUsersRequest.h
@@ -225,12 +267,22 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/ListUserAdOrganizationUnitsResult.h
 	include/alibabacloud/ecd/model/LockVirtualMFADeviceRequest.h
 	include/alibabacloud/ecd/model/LockVirtualMFADeviceResult.h
+	include/alibabacloud/ecd/model/MigrateDesktopsRequest.h
+	include/alibabacloud/ecd/model/MigrateDesktopsResult.h
 	include/alibabacloud/ecd/model/ModifyADConnectorDirectoryRequest.h
 	include/alibabacloud/ecd/model/ModifyADConnectorDirectoryResult.h
 	include/alibabacloud/ecd/model/ModifyADConnectorOfficeSiteRequest.h
 	include/alibabacloud/ecd/model/ModifyADConnectorOfficeSiteResult.h
+	include/alibabacloud/ecd/model/ModifyAutoSnapshotPolicyRequest.h
+	include/alibabacloud/ecd/model/ModifyAutoSnapshotPolicyResult.h
 	include/alibabacloud/ecd/model/ModifyBundleRequest.h
 	include/alibabacloud/ecd/model/ModifyBundleResult.h
+	include/alibabacloud/ecd/model/ModifyCdsFileRequest.h
+	include/alibabacloud/ecd/model/ModifyCdsFileResult.h
+	include/alibabacloud/ecd/model/ModifyCdsFileShareLinkRequest.h
+	include/alibabacloud/ecd/model/ModifyCdsFileShareLinkResult.h
+	include/alibabacloud/ecd/model/ModifyCloudDriveGroupsRequest.h
+	include/alibabacloud/ecd/model/ModifyCloudDriveGroupsResult.h
 	include/alibabacloud/ecd/model/ModifyCloudDrivePermissionRequest.h
 	include/alibabacloud/ecd/model/ModifyCloudDrivePermissionResult.h
 	include/alibabacloud/ecd/model/ModifyCustomizedListHeadersRequest.h
@@ -275,12 +327,16 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/ModifyUserEntitlementResult.h
 	include/alibabacloud/ecd/model/ModifyUserToDesktopGroupRequest.h
 	include/alibabacloud/ecd/model/ModifyUserToDesktopGroupResult.h
+	include/alibabacloud/ecd/model/MoveCdsFileRequest.h
+	include/alibabacloud/ecd/model/MoveCdsFileResult.h
 	include/alibabacloud/ecd/model/OperateVulsRequest.h
 	include/alibabacloud/ecd/model/OperateVulsResult.h
 	include/alibabacloud/ecd/model/RebootDesktopsRequest.h
 	include/alibabacloud/ecd/model/RebootDesktopsResult.h
 	include/alibabacloud/ecd/model/RebuildDesktopsRequest.h
 	include/alibabacloud/ecd/model/RebuildDesktopsResult.h
+	include/alibabacloud/ecd/model/RemoveFilePermissionRequest.h
+	include/alibabacloud/ecd/model/RemoveFilePermissionResult.h
 	include/alibabacloud/ecd/model/RemoveUserFromDesktopGroupRequest.h
 	include/alibabacloud/ecd/model/RemoveUserFromDesktopGroupResult.h
 	include/alibabacloud/ecd/model/RenewDesktopsRequest.h
@@ -301,14 +357,20 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/RunCommandResult.h
 	include/alibabacloud/ecd/model/SendVerifyCodeRequest.h
 	include/alibabacloud/ecd/model/SendVerifyCodeResult.h
+	include/alibabacloud/ecd/model/SetDesktopGroupScaleTimerRequest.h
+	include/alibabacloud/ecd/model/SetDesktopGroupScaleTimerResult.h
 	include/alibabacloud/ecd/model/SetDesktopGroupTimerRequest.h
 	include/alibabacloud/ecd/model/SetDesktopGroupTimerResult.h
 	include/alibabacloud/ecd/model/SetDesktopGroupTimerStatusRequest.h
 	include/alibabacloud/ecd/model/SetDesktopGroupTimerStatusResult.h
+	include/alibabacloud/ecd/model/SetDirectorySsoStatusRequest.h
+	include/alibabacloud/ecd/model/SetDirectorySsoStatusResult.h
 	include/alibabacloud/ecd/model/SetIdpMetadataRequest.h
 	include/alibabacloud/ecd/model/SetIdpMetadataResult.h
 	include/alibabacloud/ecd/model/SetOfficeSiteSsoStatusRequest.h
 	include/alibabacloud/ecd/model/SetOfficeSiteSsoStatusResult.h
+	include/alibabacloud/ecd/model/SetUserProfilePathRulesRequest.h
+	include/alibabacloud/ecd/model/SetUserProfilePathRulesResult.h
 	include/alibabacloud/ecd/model/StartDesktopsRequest.h
 	include/alibabacloud/ecd/model/StartDesktopsResult.h
 	include/alibabacloud/ecd/model/StartVirusScanTaskRequest.h
@@ -328,14 +390,22 @@ set(ecd_public_header_model
 	include/alibabacloud/ecd/model/UploadImageRequest.h
 	include/alibabacloud/ecd/model/UploadImageResult.h
 	include/alibabacloud/ecd/model/VerifyCenRequest.h
-	include/alibabacloud/ecd/model/VerifyCenResult.h )
+	include/alibabacloud/ecd/model/VerifyCenResult.h
+	include/alibabacloud/ecd/model/WakeupDesktopsRequest.h
+	include/alibabacloud/ecd/model/WakeupDesktopsResult.h )
 
 set(ecd_src 
 	src/EcdClient.cc
 	src/model/ActivateOfficeSiteRequest.cc
 	src/model/ActivateOfficeSiteResult.cc
+	src/model/AddDevicesRequest.cc
+	src/model/AddDevicesResult.cc
+	src/model/AddFilePermissionRequest.cc
+	src/model/AddFilePermissionResult.cc
 	src/model/AddUserToDesktopGroupRequest.cc
 	src/model/AddUserToDesktopGroupResult.cc
+	src/model/ApplyAutoSnapshotPolicyRequest.cc
+	src/model/ApplyAutoSnapshotPolicyResult.cc
 	src/model/ApplyCoordinatePrivilegeRequest.cc
 	src/model/ApplyCoordinatePrivilegeResult.cc
 	src/model/ApplyCoordinationForMonitoringRequest.cc
@@ -346,16 +416,26 @@ set(ecd_src
 	src/model/AssociateNetworkPackageResult.cc
 	src/model/AttachCenRequest.cc
 	src/model/AttachCenResult.cc
+	src/model/AttachEndUserRequest.cc
+	src/model/AttachEndUserResult.cc
+	src/model/CancelAutoSnapshotPolicyRequest.cc
+	src/model/CancelAutoSnapshotPolicyResult.cc
+	src/model/CancelCdsFileShareLinkRequest.cc
+	src/model/CancelCdsFileShareLinkResult.cc
 	src/model/CancelCoordinationForMonitoringRequest.cc
 	src/model/CancelCoordinationForMonitoringResult.cc
 	src/model/CancelCopyImageRequest.cc
 	src/model/CancelCopyImageResult.cc
 	src/model/ClonePolicyGroupRequest.cc
 	src/model/ClonePolicyGroupResult.cc
+	src/model/CompleteCdsFileRequest.cc
+	src/model/CompleteCdsFileResult.cc
 	src/model/ConfigADConnectorTrustRequest.cc
 	src/model/ConfigADConnectorTrustResult.cc
 	src/model/ConfigADConnectorUserRequest.cc
 	src/model/ConfigADConnectorUserResult.cc
+	src/model/CopyCdsFileRequest.cc
+	src/model/CopyCdsFileResult.cc
 	src/model/CopyImageRequest.cc
 	src/model/CopyImageResult.cc
 	src/model/CreateADConnectorDirectoryRequest.cc
@@ -364,16 +444,20 @@ set(ecd_src
 	src/model/CreateADConnectorOfficeSiteResult.cc
 	src/model/CreateAndBindNasFileSystemRequest.cc
 	src/model/CreateAndBindNasFileSystemResult.cc
+	src/model/CreateAutoSnapshotPolicyRequest.cc
+	src/model/CreateAutoSnapshotPolicyResult.cc
 	src/model/CreateBundleRequest.cc
 	src/model/CreateBundleResult.cc
+	src/model/CreateCdsFileRequest.cc
+	src/model/CreateCdsFileResult.cc
+	src/model/CreateCdsFileShareLinkRequest.cc
+	src/model/CreateCdsFileShareLinkResult.cc
 	src/model/CreateDesktopGroupRequest.cc
 	src/model/CreateDesktopGroupResult.cc
 	src/model/CreateDesktopsRequest.cc
 	src/model/CreateDesktopsResult.cc
 	src/model/CreateDiskEncryptionServiceRequest.cc
 	src/model/CreateDiskEncryptionServiceResult.cc
-	src/model/CreateDriveRequest.cc
-	src/model/CreateDriveResult.cc
 	src/model/CreateImageRequest.cc
 	src/model/CreateImageResult.cc
 	src/model/CreateNASFileSystemRequest.cc
@@ -388,18 +472,24 @@ set(ecd_src
 	src/model/CreateSimpleOfficeSiteResult.cc
 	src/model/CreateSnapshotRequest.cc
 	src/model/CreateSnapshotResult.cc
+	src/model/DeleteAutoSnapshotPolicyRequest.cc
+	src/model/DeleteAutoSnapshotPolicyResult.cc
 	src/model/DeleteBundlesRequest.cc
 	src/model/DeleteBundlesResult.cc
+	src/model/DeleteCdsFileRequest.cc
+	src/model/DeleteCdsFileResult.cc
+	src/model/DeleteCloudDriveGroupsRequest.cc
+	src/model/DeleteCloudDriveGroupsResult.cc
 	src/model/DeleteCloudDriveUsersRequest.cc
 	src/model/DeleteCloudDriveUsersResult.cc
 	src/model/DeleteDesktopGroupRequest.cc
 	src/model/DeleteDesktopGroupResult.cc
 	src/model/DeleteDesktopsRequest.cc
 	src/model/DeleteDesktopsResult.cc
+	src/model/DeleteDevicesRequest.cc
+	src/model/DeleteDevicesResult.cc
 	src/model/DeleteDirectoriesRequest.cc
 	src/model/DeleteDirectoriesResult.cc
-	src/model/DeleteDriveRequest.cc
-	src/model/DeleteDriveResult.cc
 	src/model/DeleteImagesRequest.cc
 	src/model/DeleteImagesResult.cc
 	src/model/DeleteNASFileSystemsRequest.cc
@@ -416,12 +506,18 @@ set(ecd_src
 	src/model/DeleteVirtualMFADeviceResult.cc
 	src/model/DescribeAlarmEventStackInfoRequest.cc
 	src/model/DescribeAlarmEventStackInfoResult.cc
+	src/model/DescribeAutoSnapshotPolicyRequest.cc
+	src/model/DescribeAutoSnapshotPolicyResult.cc
 	src/model/DescribeBundlesRequest.cc
 	src/model/DescribeBundlesResult.cc
+	src/model/DescribeCdsFileShareLinksRequest.cc
+	src/model/DescribeCdsFileShareLinksResult.cc
 	src/model/DescribeCensRequest.cc
 	src/model/DescribeCensResult.cc
 	src/model/DescribeClientEventsRequest.cc
 	src/model/DescribeClientEventsResult.cc
+	src/model/DescribeCloudDriveGroupsRequest.cc
+	src/model/DescribeCloudDriveGroupsResult.cc
 	src/model/DescribeCloudDrivePermissionsRequest.cc
 	src/model/DescribeCloudDrivePermissionsResult.cc
 	src/model/DescribeCustomizedListHeadersRequest.cc
@@ -436,10 +532,10 @@ set(ecd_src
 	src/model/DescribeDesktopsResult.cc
 	src/model/DescribeDesktopsInGroupRequest.cc
 	src/model/DescribeDesktopsInGroupResult.cc
+	src/model/DescribeDevicesRequest.cc
+	src/model/DescribeDevicesResult.cc
 	src/model/DescribeDirectoriesRequest.cc
 	src/model/DescribeDirectoriesResult.cc
-	src/model/DescribeDrivesRequest.cc
-	src/model/DescribeDrivesResult.cc
 	src/model/DescribeFlowMetricRequest.cc
 	src/model/DescribeFlowMetricResult.cc
 	src/model/DescribeFlowStatisticRequest.cc
@@ -488,6 +584,8 @@ set(ecd_src
 	src/model/DescribeSuspEventsResult.cc
 	src/model/DescribeUserConnectionRecordsRequest.cc
 	src/model/DescribeUserConnectionRecordsResult.cc
+	src/model/DescribeUserProfilePathRulesRequest.cc
+	src/model/DescribeUserProfilePathRulesResult.cc
 	src/model/DescribeUsersInGroupRequest.cc
 	src/model/DescribeUsersInGroupResult.cc
 	src/model/DescribeUsersPasswordRequest.cc
@@ -504,6 +602,8 @@ set(ecd_src
 	src/model/DescribeZonesResult.cc
 	src/model/DetachCenRequest.cc
 	src/model/DetachCenResult.cc
+	src/model/DetachEndUserRequest.cc
+	src/model/DetachEndUserResult.cc
 	src/model/DisableDesktopsInGroupRequest.cc
 	src/model/DisableDesktopsInGroupResult.cc
 	src/model/DissociateNetworkPackageRequest.cc
@@ -524,8 +624,14 @@ set(ecd_src
 	src/model/GetSpMetadataResult.cc
 	src/model/HandleSecurityEventsRequest.cc
 	src/model/HandleSecurityEventsResult.cc
+	src/model/HibernateDesktopsRequest.cc
+	src/model/HibernateDesktopsResult.cc
+	src/model/ListCdsFilesRequest.cc
+	src/model/ListCdsFilesResult.cc
 	src/model/ListDirectoryUsersRequest.cc
 	src/model/ListDirectoryUsersResult.cc
+	src/model/ListFilePermissionRequest.cc
+	src/model/ListFilePermissionResult.cc
 	src/model/ListOfficeSiteOverviewRequest.cc
 	src/model/ListOfficeSiteOverviewResult.cc
 	src/model/ListOfficeSiteUsersRequest.cc
@@ -536,12 +642,22 @@ set(ecd_src
 	src/model/ListUserAdOrganizationUnitsResult.cc
 	src/model/LockVirtualMFADeviceRequest.cc
 	src/model/LockVirtualMFADeviceResult.cc
+	src/model/MigrateDesktopsRequest.cc
+	src/model/MigrateDesktopsResult.cc
 	src/model/ModifyADConnectorDirectoryRequest.cc
 	src/model/ModifyADConnectorDirectoryResult.cc
 	src/model/ModifyADConnectorOfficeSiteRequest.cc
 	src/model/ModifyADConnectorOfficeSiteResult.cc
+	src/model/ModifyAutoSnapshotPolicyRequest.cc
+	src/model/ModifyAutoSnapshotPolicyResult.cc
 	src/model/ModifyBundleRequest.cc
 	src/model/ModifyBundleResult.cc
+	src/model/ModifyCdsFileRequest.cc
+	src/model/ModifyCdsFileResult.cc
+	src/model/ModifyCdsFileShareLinkRequest.cc
+	src/model/ModifyCdsFileShareLinkResult.cc
+	src/model/ModifyCloudDriveGroupsRequest.cc
+	src/model/ModifyCloudDriveGroupsResult.cc
 	src/model/ModifyCloudDrivePermissionRequest.cc
 	src/model/ModifyCloudDrivePermissionResult.cc
 	src/model/ModifyCustomizedListHeadersRequest.cc
@@ -586,12 +702,16 @@ set(ecd_src
 	src/model/ModifyUserEntitlementResult.cc
 	src/model/ModifyUserToDesktopGroupRequest.cc
 	src/model/ModifyUserToDesktopGroupResult.cc
+	src/model/MoveCdsFileRequest.cc
+	src/model/MoveCdsFileResult.cc
 	src/model/OperateVulsRequest.cc
 	src/model/OperateVulsResult.cc
 	src/model/RebootDesktopsRequest.cc
 	src/model/RebootDesktopsResult.cc
 	src/model/RebuildDesktopsRequest.cc
 	src/model/RebuildDesktopsResult.cc
+	src/model/RemoveFilePermissionRequest.cc
+	src/model/RemoveFilePermissionResult.cc
 	src/model/RemoveUserFromDesktopGroupRequest.cc
 	src/model/RemoveUserFromDesktopGroupResult.cc
 	src/model/RenewDesktopsRequest.cc
@@ -612,14 +732,20 @@ set(ecd_src
 	src/model/RunCommandResult.cc
 	src/model/SendVerifyCodeRequest.cc
 	src/model/SendVerifyCodeResult.cc
+	src/model/SetDesktopGroupScaleTimerRequest.cc
+	src/model/SetDesktopGroupScaleTimerResult.cc
 	src/model/SetDesktopGroupTimerRequest.cc
 	src/model/SetDesktopGroupTimerResult.cc
 	src/model/SetDesktopGroupTimerStatusRequest.cc
 	src/model/SetDesktopGroupTimerStatusResult.cc
+	src/model/SetDirectorySsoStatusRequest.cc
+	src/model/SetDirectorySsoStatusResult.cc
 	src/model/SetIdpMetadataRequest.cc
 	src/model/SetIdpMetadataResult.cc
 	src/model/SetOfficeSiteSsoStatusRequest.cc
 	src/model/SetOfficeSiteSsoStatusResult.cc
+	src/model/SetUserProfilePathRulesRequest.cc
+	src/model/SetUserProfilePathRulesResult.cc
 	src/model/StartDesktopsRequest.cc
 	src/model/StartDesktopsResult.cc
 	src/model/StartVirusScanTaskRequest.cc
@@ -639,7 +765,9 @@ set(ecd_src
 	src/model/UploadImageRequest.cc
 	src/model/UploadImageResult.cc
 	src/model/VerifyCenRequest.cc
-	src/model/VerifyCenResult.cc )
+	src/model/VerifyCenResult.cc
+	src/model/WakeupDesktopsRequest.cc
+	src/model/WakeupDesktopsResult.cc )
 
 add_library(ecd ${LIB_TYPE}
 	${ecd_public_header}

ecd/include/alibabacloud/ecd/EcdClient.h

@@ -24,8 +24,14 @@
 #include "EcdExport.h"
 #include "model/ActivateOfficeSiteRequest.h"
 #include "model/ActivateOfficeSiteResult.h"
+#include "model/AddDevicesRequest.h"
+#include "model/AddDevicesResult.h"
+#include "model/AddFilePermissionRequest.h"
+#include "model/AddFilePermissionResult.h"
 #include "model/AddUserToDesktopGroupRequest.h"
 #include "model/AddUserToDesktopGroupResult.h"
+#include "model/ApplyAutoSnapshotPolicyRequest.h"
+#include "model/ApplyAutoSnapshotPolicyResult.h"
 #include "model/ApplyCoordinatePrivilegeRequest.h"
 #include "model/ApplyCoordinatePrivilegeResult.h"
 #include "model/ApplyCoordinationForMonitoringRequest.h"
@@ -36,16 +42,26 @@
 #include "model/AssociateNetworkPackageResult.h"
 #include "model/AttachCenRequest.h"
 #include "model/AttachCenResult.h"
+#include "model/AttachEndUserRequest.h"
+#include "model/AttachEndUserResult.h"
+#include "model/CancelAutoSnapshotPolicyRequest.h"
+#include "model/CancelAutoSnapshotPolicyResult.h"
+#include "model/CancelCdsFileShareLinkRequest.h"
+#include "model/CancelCdsFileShareLinkResult.h"
 #include "model/CancelCoordinationForMonitoringRequest.h"
 #include "model/CancelCoordinationForMonitoringResult.h"
 #include "model/CancelCopyImageRequest.h"
 #include "model/CancelCopyImageResult.h"
 #include "model/ClonePolicyGroupRequest.h"
 #include "model/ClonePolicyGroupResult.h"
+#include "model/CompleteCdsFileRequest.h"
+#include "model/CompleteCdsFileResult.h"
 #include "model/ConfigADConnectorTrustRequest.h"
 #include "model/ConfigADConnectorTrustResult.h"
 #include "model/ConfigADConnectorUserRequest.h"
 #include "model/ConfigADConnectorUserResult.h"
+#include "model/CopyCdsFileRequest.h"
+#include "model/CopyCdsFileResult.h"
 #include "model/CopyImageRequest.h"
 #include "model/CopyImageResult.h"
 #include "model/CreateADConnectorDirectoryRequest.h"
@@ -54,16 +70,20 @@
 #include "model/CreateADConnectorOfficeSiteResult.h"
 #include "model/CreateAndBindNasFileSystemRequest.h"
 #include "model/CreateAndBindNasFileSystemResult.h"
+#include "model/CreateAutoSnapshotPolicyRequest.h"
+#include "model/CreateAutoSnapshotPolicyResult.h"
 #include "model/CreateBundleRequest.h"
 #include "model/CreateBundleResult.h"
+#include "model/CreateCdsFileRequest.h"
+#include "model/CreateCdsFileResult.h"
+#include "model/CreateCdsFileShareLinkRequest.h"
+#include "model/CreateCdsFileShareLinkResult.h"
 #include "model/CreateDesktopGroupRequest.h"
 #include "model/CreateDesktopGroupResult.h"
 #include "model/CreateDesktopsRequest.h"
 #include "model/CreateDesktopsResult.h"
 #include "model/CreateDiskEncryptionServiceRequest.h"
 #include "model/CreateDiskEncryptionServiceResult.h"
-#include "model/CreateDriveRequest.h"
-#include "model/CreateDriveResult.h"
 #include "model/CreateImageRequest.h"
 #include "model/CreateImageResult.h"
 #include "model/CreateNASFileSystemRequest.h"
@@ -78,18 +98,24 @@
 #include "model/CreateSimpleOfficeSiteResult.h"
 #include "model/CreateSnapshotRequest.h"
 #include "model/CreateSnapshotResult.h"
+#include "model/DeleteAutoSnapshotPolicyRequest.h"
+#include "model/DeleteAutoSnapshotPolicyResult.h"
 #include "model/DeleteBundlesRequest.h"
 #include "model/DeleteBundlesResult.h"
+#include "model/DeleteCdsFileRequest.h"
+#include "model/DeleteCdsFileResult.h"
+#include "model/DeleteCloudDriveGroupsRequest.h"
+#include "model/DeleteCloudDriveGroupsResult.h"
 #include "model/DeleteCloudDriveUsersRequest.h"
 #include "model/DeleteCloudDriveUsersResult.h"
 #include "model/DeleteDesktopGroupRequest.h"
 #include "model/DeleteDesktopGroupResult.h"
 #include "model/DeleteDesktopsRequest.h"
 #include "model/DeleteDesktopsResult.h"
+#include "model/DeleteDevicesRequest.h"
+#include "model/DeleteDevicesResult.h"
 #include "model/DeleteDirectoriesRequest.h"
 #include "model/DeleteDirectoriesResult.h"
-#include "model/DeleteDriveRequest.h"
-#include "model/DeleteDriveResult.h"
 #include "model/DeleteImagesRequest.h"
 #include "model/DeleteImagesResult.h"
 #include "model/DeleteNASFileSystemsRequest.h"
@@ -106,12 +132,18 @@
 #include "model/DeleteVirtualMFADeviceResult.h"
 #include "model/DescribeAlarmEventStackInfoRequest.h"
 #include "model/DescribeAlarmEventStackInfoResult.h"
+#include "model/DescribeAutoSnapshotPolicyRequest.h"
+#include "model/DescribeAutoSnapshotPolicyResult.h"
 #include "model/DescribeBundlesRequest.h"
 #include "model/DescribeBundlesResult.h"
+#include "model/DescribeCdsFileShareLinksRequest.h"
+#include "model/DescribeCdsFileShareLinksResult.h"
 #include "model/DescribeCensRequest.h"
 #include "model/DescribeCensResult.h"
 #include "model/DescribeClientEventsRequest.h"
 #include "model/DescribeClientEventsResult.h"
+#include "model/DescribeCloudDriveGroupsRequest.h"
+#include "model/DescribeCloudDriveGroupsResult.h"
 #include "model/DescribeCloudDrivePermissionsRequest.h"
 #include "model/DescribeCloudDrivePermissionsResult.h"
 #include "model/DescribeCustomizedListHeadersRequest.h"
@@ -126,10 +158,10 @@
 #include "model/DescribeDesktopsResult.h"
 #include "model/DescribeDesktopsInGroupRequest.h"
 #include "model/DescribeDesktopsInGroupResult.h"
+#include "model/DescribeDevicesRequest.h"
+#include "model/DescribeDevicesResult.h"
 #include "model/DescribeDirectoriesRequest.h"
 #include "model/DescribeDirectoriesResult.h"
-#include "model/DescribeDrivesRequest.h"
-#include "model/DescribeDrivesResult.h"
 #include "model/DescribeFlowMetricRequest.h"
 #include "model/DescribeFlowMetricResult.h"
 #include "model/DescribeFlowStatisticRequest.h"
@@ -178,6 +210,8 @@
 #include "model/DescribeSuspEventsResult.h"
 #include "model/DescribeUserConnectionRecordsRequest.h"
 #include "model/DescribeUserConnectionRecordsResult.h"
+#include "model/DescribeUserProfilePathRulesRequest.h"
+#include "model/DescribeUserProfilePathRulesResult.h"
 #include "model/DescribeUsersInGroupRequest.h"
 #include "model/DescribeUsersInGroupResult.h"
 #include "model/DescribeUsersPasswordRequest.h"
@@ -194,6 +228,8 @@
 #include "model/DescribeZonesResult.h"
 #include "model/DetachCenRequest.h"
 #include "model/DetachCenResult.h"
+#include "model/DetachEndUserRequest.h"
+#include "model/DetachEndUserResult.h"
 #include "model/DisableDesktopsInGroupRequest.h"
 #include "model/DisableDesktopsInGroupResult.h"
 #include "model/DissociateNetworkPackageRequest.h"
@@ -214,8 +250,14 @@
 #include "model/GetSpMetadataResult.h"
 #include "model/HandleSecurityEventsRequest.h"
 #include "model/HandleSecurityEventsResult.h"
+#include "model/HibernateDesktopsRequest.h"
+#include "model/HibernateDesktopsResult.h"
+#include "model/ListCdsFilesRequest.h"
+#include "model/ListCdsFilesResult.h"
 #include "model/ListDirectoryUsersRequest.h"
 #include "model/ListDirectoryUsersResult.h"
+#include "model/ListFilePermissionRequest.h"
+#include "model/ListFilePermissionResult.h"
 #include "model/ListOfficeSiteOverviewRequest.h"
 #include "model/ListOfficeSiteOverviewResult.h"
 #include "model/ListOfficeSiteUsersRequest.h"
@@ -226,12 +268,22 @@
 #include "model/ListUserAdOrganizationUnitsResult.h"
 #include "model/LockVirtualMFADeviceRequest.h"
 #include "model/LockVirtualMFADeviceResult.h"
+#include "model/MigrateDesktopsRequest.h"
+#include "model/MigrateDesktopsResult.h"
 #include "model/ModifyADConnectorDirectoryRequest.h"
 #include "model/ModifyADConnectorDirectoryResult.h"
 #include "model/ModifyADConnectorOfficeSiteRequest.h"
 #include "model/ModifyADConnectorOfficeSiteResult.h"
+#include "model/ModifyAutoSnapshotPolicyRequest.h"
+#include "model/ModifyAutoSnapshotPolicyResult.h"
 #include "model/ModifyBundleRequest.h"
 #include "model/ModifyBundleResult.h"
+#include "model/ModifyCdsFileRequest.h"
+#include "model/ModifyCdsFileResult.h"
+#include "model/ModifyCdsFileShareLinkRequest.h"
+#include "model/ModifyCdsFileShareLinkResult.h"
+#include "model/ModifyCloudDriveGroupsRequest.h"
+#include "model/ModifyCloudDriveGroupsResult.h"
 #include "model/ModifyCloudDrivePermissionRequest.h"
 #include "model/ModifyCloudDrivePermissionResult.h"
 #include "model/ModifyCustomizedListHeadersRequest.h"
@@ -276,12 +328,16 @@
 #include "model/ModifyUserEntitlementResult.h"
 #include "model/ModifyUserToDesktopGroupRequest.h"
 #include "model/ModifyUserToDesktopGroupResult.h"
+#include "model/MoveCdsFileRequest.h"
+#include "model/MoveCdsFileResult.h"
 #include "model/OperateVulsRequest.h"
 #include "model/OperateVulsResult.h"
 #include "model/RebootDesktopsRequest.h"
 #include "model/RebootDesktopsResult.h"
 #include "model/RebuildDesktopsRequest.h"
 #include "model/RebuildDesktopsResult.h"
+#include "model/RemoveFilePermissionRequest.h"
+#include "model/RemoveFilePermissionResult.h"
 #include "model/RemoveUserFromDesktopGroupRequest.h"
 #include "model/RemoveUserFromDesktopGroupResult.h"
 #include "model/RenewDesktopsRequest.h"
@@ -302,14 +358,20 @@
 #include "model/RunCommandResult.h"
 #include "model/SendVerifyCodeRequest.h"
 #include "model/SendVerifyCodeResult.h"
+#include "model/SetDesktopGroupScaleTimerRequest.h"
+#include "model/SetDesktopGroupScaleTimerResult.h"
 #include "model/SetDesktopGroupTimerRequest.h"
 #include "model/SetDesktopGroupTimerResult.h"
 #include "model/SetDesktopGroupTimerStatusRequest.h"
 #include "model/SetDesktopGroupTimerStatusResult.h"
+#include "model/SetDirectorySsoStatusRequest.h"
+#include "model/SetDirectorySsoStatusResult.h"
 #include "model/SetIdpMetadataRequest.h"
 #include "model/SetIdpMetadataResult.h"
 #include "model/SetOfficeSiteSsoStatusRequest.h"
 #include "model/SetOfficeSiteSsoStatusResult.h"
+#include "model/SetUserProfilePathRulesRequest.h"
+#include "model/SetUserProfilePathRulesResult.h"
 #include "model/StartDesktopsRequest.h"
 #include "model/StartDesktopsResult.h"
 #include "model/StartVirusScanTaskRequest.h"
@@ -330,6 +392,8 @@
 #include "model/UploadImageResult.h"
 #include "model/VerifyCenRequest.h"
 #include "model/VerifyCenResult.h"
+#include "model/WakeupDesktopsRequest.h"
+#include "model/WakeupDesktopsResult.h"
 
 
 namespace AlibabaCloud
@@ -342,9 +406,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ActivateOfficeSiteResult> ActivateOfficeSiteOutcome;
 			typedef std::future<ActivateOfficeSiteOutcome> ActivateOfficeSiteOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ActivateOfficeSiteRequest&, const ActivateOfficeSiteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ActivateOfficeSiteAsyncHandler;
+			typedef Outcome<Error, Model::AddDevicesResult> AddDevicesOutcome;
+			typedef std::future<AddDevicesOutcome> AddDevicesOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::AddDevicesRequest&, const AddDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddDevicesAsyncHandler;
+			typedef Outcome<Error, Model::AddFilePermissionResult> AddFilePermissionOutcome;
+			typedef std::future<AddFilePermissionOutcome> AddFilePermissionOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::AddFilePermissionRequest&, const AddFilePermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddFilePermissionAsyncHandler;
 			typedef Outcome<Error, Model::AddUserToDesktopGroupResult> AddUserToDesktopGroupOutcome;
 			typedef std::future<AddUserToDesktopGroupOutcome> AddUserToDesktopGroupOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::AddUserToDesktopGroupRequest&, const AddUserToDesktopGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddUserToDesktopGroupAsyncHandler;
+			typedef Outcome<Error, Model::ApplyAutoSnapshotPolicyResult> ApplyAutoSnapshotPolicyOutcome;
+			typedef std::future<ApplyAutoSnapshotPolicyOutcome> ApplyAutoSnapshotPolicyOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::ApplyAutoSnapshotPolicyRequest&, const ApplyAutoSnapshotPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyAutoSnapshotPolicyAsyncHandler;
 			typedef Outcome<Error, Model::ApplyCoordinatePrivilegeResult> ApplyCoordinatePrivilegeOutcome;
 			typedef std::future<ApplyCoordinatePrivilegeOutcome> ApplyCoordinatePrivilegeOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ApplyCoordinatePrivilegeRequest&, const ApplyCoordinatePrivilegeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyCoordinatePrivilegeAsyncHandler;
@@ -360,6 +433,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::AttachCenResult> AttachCenOutcome;
 			typedef std::future<AttachCenOutcome> AttachCenOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::AttachCenRequest&, const AttachCenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachCenAsyncHandler;
+			typedef Outcome<Error, Model::AttachEndUserResult> AttachEndUserOutcome;
+			typedef std::future<AttachEndUserOutcome> AttachEndUserOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::AttachEndUserRequest&, const AttachEndUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AttachEndUserAsyncHandler;
+			typedef Outcome<Error, Model::CancelAutoSnapshotPolicyResult> CancelAutoSnapshotPolicyOutcome;
+			typedef std::future<CancelAutoSnapshotPolicyOutcome> CancelAutoSnapshotPolicyOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::CancelAutoSnapshotPolicyRequest&, const CancelAutoSnapshotPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelAutoSnapshotPolicyAsyncHandler;
+			typedef Outcome<Error, Model::CancelCdsFileShareLinkResult> CancelCdsFileShareLinkOutcome;
+			typedef std::future<CancelCdsFileShareLinkOutcome> CancelCdsFileShareLinkOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::CancelCdsFileShareLinkRequest&, const CancelCdsFileShareLinkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelCdsFileShareLinkAsyncHandler;
 			typedef Outcome<Error, Model::CancelCoordinationForMonitoringResult> CancelCoordinationForMonitoringOutcome;
 			typedef std::future<CancelCoordinationForMonitoringOutcome> CancelCoordinationForMonitoringOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::CancelCoordinationForMonitoringRequest&, const CancelCoordinationForMonitoringOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelCoordinationForMonitoringAsyncHandler;
@@ -369,12 +451,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ClonePolicyGroupResult> ClonePolicyGroupOutcome;
 			typedef std::future<ClonePolicyGroupOutcome> ClonePolicyGroupOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ClonePolicyGroupRequest&, const ClonePolicyGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ClonePolicyGroupAsyncHandler;
+			typedef Outcome<Error, Model::CompleteCdsFileResult> CompleteCdsFileOutcome;
+			typedef std::future<CompleteCdsFileOutcome> CompleteCdsFileOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::CompleteCdsFileRequest&, const CompleteCdsFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CompleteCdsFileAsyncHandler;
 			typedef Outcome<Error, Model::ConfigADConnectorTrustResult> ConfigADConnectorTrustOutcome;
 			typedef std::future<ConfigADConnectorTrustOutcome> ConfigADConnectorTrustOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ConfigADConnectorTrustRequest&, const ConfigADConnectorTrustOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfigADConnectorTrustAsyncHandler;
 			typedef Outcome<Error, Model::ConfigADConnectorUserResult> ConfigADConnectorUserOutcome;
 			typedef std::future<ConfigADConnectorUserOutcome> ConfigADConnectorUserOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ConfigADConnectorUserRequest&, const ConfigADConnectorUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ConfigADConnectorUserAsyncHandler;
+			typedef Outcome<Error, Model::CopyCdsFileResult> CopyCdsFileOutcome;
+			typedef std::future<CopyCdsFileOutcome> CopyCdsFileOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::CopyCdsFileRequest&, const CopyCdsFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CopyCdsFileAsyncHandler;
 			typedef Outcome<Error, Model::CopyImageResult> CopyImageOutcome;
 			typedef std::future<CopyImageOutcome> CopyImageOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::CopyImageRequest&, const CopyImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CopyImageAsyncHandler;
@@ -387,9 +475,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateAndBindNasFileSystemResult> CreateAndBindNasFileSystemOutcome;
 			typedef std::future<CreateAndBindNasFileSystemOutcome> CreateAndBindNasFileSystemOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::CreateAndBindNasFileSystemRequest&, const CreateAndBindNasFileSystemOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAndBindNasFileSystemAsyncHandler;
+			typedef Outcome<Error, Model::CreateAutoSnapshotPolicyResult> CreateAutoSnapshotPolicyOutcome;
+			typedef std::future<CreateAutoSnapshotPolicyOutcome> CreateAutoSnapshotPolicyOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::CreateAutoSnapshotPolicyRequest&, const CreateAutoSnapshotPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAutoSnapshotPolicyAsyncHandler;
 			typedef Outcome<Error, Model::CreateBundleResult> CreateBundleOutcome;
 			typedef std::future<CreateBundleOutcome> CreateBundleOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::CreateBundleRequest&, const CreateBundleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBundleAsyncHandler;
+			typedef Outcome<Error, Model::CreateCdsFileResult> CreateCdsFileOutcome;
+			typedef std::future<CreateCdsFileOutcome> CreateCdsFileOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::CreateCdsFileRequest&, const CreateCdsFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCdsFileAsyncHandler;
+			typedef Outcome<Error, Model::CreateCdsFileShareLinkResult> CreateCdsFileShareLinkOutcome;
+			typedef std::future<CreateCdsFileShareLinkOutcome> CreateCdsFileShareLinkOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::CreateCdsFileShareLinkRequest&, const CreateCdsFileShareLinkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCdsFileShareLinkAsyncHandler;
 			typedef Outcome<Error, Model::CreateDesktopGroupResult> CreateDesktopGroupOutcome;
 			typedef std::future<CreateDesktopGroupOutcome> CreateDesktopGroupOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::CreateDesktopGroupRequest&, const CreateDesktopGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDesktopGroupAsyncHandler;
@@ -399,9 +496,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateDiskEncryptionServiceResult> CreateDiskEncryptionServiceOutcome;
 			typedef std::future<CreateDiskEncryptionServiceOutcome> CreateDiskEncryptionServiceOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::CreateDiskEncryptionServiceRequest&, const CreateDiskEncryptionServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDiskEncryptionServiceAsyncHandler;
-			typedef Outcome<Error, Model::CreateDriveResult> CreateDriveOutcome;
-			typedef std::future<CreateDriveOutcome> CreateDriveOutcomeCallable;
-			typedef std::function<void(const EcdClient*, const Model::CreateDriveRequest&, const CreateDriveOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDriveAsyncHandler;
 			typedef Outcome<Error, Model::CreateImageResult> CreateImageOutcome;
 			typedef std::future<CreateImageOutcome> CreateImageOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::CreateImageRequest&, const CreateImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateImageAsyncHandler;
@@ -423,9 +517,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateSnapshotResult> CreateSnapshotOutcome;
 			typedef std::future<CreateSnapshotOutcome> CreateSnapshotOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::CreateSnapshotRequest&, const CreateSnapshotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSnapshotAsyncHandler;
+			typedef Outcome<Error, Model::DeleteAutoSnapshotPolicyResult> DeleteAutoSnapshotPolicyOutcome;
+			typedef std::future<DeleteAutoSnapshotPolicyOutcome> DeleteAutoSnapshotPolicyOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::DeleteAutoSnapshotPolicyRequest&, const DeleteAutoSnapshotPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteAutoSnapshotPolicyAsyncHandler;
 			typedef Outcome<Error, Model::DeleteBundlesResult> DeleteBundlesOutcome;
 			typedef std::future<DeleteBundlesOutcome> DeleteBundlesOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DeleteBundlesRequest&, const DeleteBundlesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteBundlesAsyncHandler;
+			typedef Outcome<Error, Model::DeleteCdsFileResult> DeleteCdsFileOutcome;
+			typedef std::future<DeleteCdsFileOutcome> DeleteCdsFileOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::DeleteCdsFileRequest&, const DeleteCdsFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCdsFileAsyncHandler;
+			typedef Outcome<Error, Model::DeleteCloudDriveGroupsResult> DeleteCloudDriveGroupsOutcome;
+			typedef std::future<DeleteCloudDriveGroupsOutcome> DeleteCloudDriveGroupsOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::DeleteCloudDriveGroupsRequest&, const DeleteCloudDriveGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCloudDriveGroupsAsyncHandler;
 			typedef Outcome<Error, Model::DeleteCloudDriveUsersResult> DeleteCloudDriveUsersOutcome;
 			typedef std::future<DeleteCloudDriveUsersOutcome> DeleteCloudDriveUsersOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DeleteCloudDriveUsersRequest&, const DeleteCloudDriveUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCloudDriveUsersAsyncHandler;
@@ -435,12 +538,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteDesktopsResult> DeleteDesktopsOutcome;
 			typedef std::future<DeleteDesktopsOutcome> DeleteDesktopsOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DeleteDesktopsRequest&, const DeleteDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDesktopsAsyncHandler;
+			typedef Outcome<Error, Model::DeleteDevicesResult> DeleteDevicesOutcome;
+			typedef std::future<DeleteDevicesOutcome> DeleteDevicesOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::DeleteDevicesRequest&, const DeleteDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDevicesAsyncHandler;
 			typedef Outcome<Error, Model::DeleteDirectoriesResult> DeleteDirectoriesOutcome;
 			typedef std::future<DeleteDirectoriesOutcome> DeleteDirectoriesOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DeleteDirectoriesRequest&, const DeleteDirectoriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDirectoriesAsyncHandler;
-			typedef Outcome<Error, Model::DeleteDriveResult> DeleteDriveOutcome;
-			typedef std::future<DeleteDriveOutcome> DeleteDriveOutcomeCallable;
-			typedef std::function<void(const EcdClient*, const Model::DeleteDriveRequest&, const DeleteDriveOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDriveAsyncHandler;
 			typedef Outcome<Error, Model::DeleteImagesResult> DeleteImagesOutcome;
 			typedef std::future<DeleteImagesOutcome> DeleteImagesOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DeleteImagesRequest&, const DeleteImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteImagesAsyncHandler;
@@ -465,15 +568,24 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeAlarmEventStackInfoResult> DescribeAlarmEventStackInfoOutcome;
 			typedef std::future<DescribeAlarmEventStackInfoOutcome> DescribeAlarmEventStackInfoOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DescribeAlarmEventStackInfoRequest&, const DescribeAlarmEventStackInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAlarmEventStackInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeAutoSnapshotPolicyResult> DescribeAutoSnapshotPolicyOutcome;
+			typedef std::future<DescribeAutoSnapshotPolicyOutcome> DescribeAutoSnapshotPolicyOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::DescribeAutoSnapshotPolicyRequest&, const DescribeAutoSnapshotPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAutoSnapshotPolicyAsyncHandler;
 			typedef Outcome<Error, Model::DescribeBundlesResult> DescribeBundlesOutcome;
 			typedef std::future<DescribeBundlesOutcome> DescribeBundlesOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DescribeBundlesRequest&, const DescribeBundlesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBundlesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCdsFileShareLinksResult> DescribeCdsFileShareLinksOutcome;
+			typedef std::future<DescribeCdsFileShareLinksOutcome> DescribeCdsFileShareLinksOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::DescribeCdsFileShareLinksRequest&, const DescribeCdsFileShareLinksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCdsFileShareLinksAsyncHandler;
 			typedef Outcome<Error, Model::DescribeCensResult> DescribeCensOutcome;
 			typedef std::future<DescribeCensOutcome> DescribeCensOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DescribeCensRequest&, const DescribeCensOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCensAsyncHandler;
 			typedef Outcome<Error, Model::DescribeClientEventsResult> DescribeClientEventsOutcome;
 			typedef std::future<DescribeClientEventsOutcome> DescribeClientEventsOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DescribeClientEventsRequest&, const DescribeClientEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeClientEventsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCloudDriveGroupsResult> DescribeCloudDriveGroupsOutcome;
+			typedef std::future<DescribeCloudDriveGroupsOutcome> DescribeCloudDriveGroupsOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::DescribeCloudDriveGroupsRequest&, const DescribeCloudDriveGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCloudDriveGroupsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeCloudDrivePermissionsResult> DescribeCloudDrivePermissionsOutcome;
 			typedef std::future<DescribeCloudDrivePermissionsOutcome> DescribeCloudDrivePermissionsOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DescribeCloudDrivePermissionsRequest&, const DescribeCloudDrivePermissionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCloudDrivePermissionsAsyncHandler;
@@ -495,12 +607,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDesktopsInGroupResult> DescribeDesktopsInGroupOutcome;
 			typedef std::future<DescribeDesktopsInGroupOutcome> DescribeDesktopsInGroupOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DescribeDesktopsInGroupRequest&, const DescribeDesktopsInGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDesktopsInGroupAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDevicesResult> DescribeDevicesOutcome;
+			typedef std::future<DescribeDevicesOutcome> DescribeDevicesOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::DescribeDevicesRequest&, const DescribeDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDevicesAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDirectoriesResult> DescribeDirectoriesOutcome;
 			typedef std::future<DescribeDirectoriesOutcome> DescribeDirectoriesOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DescribeDirectoriesRequest&, const DescribeDirectoriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDirectoriesAsyncHandler;
-			typedef Outcome<Error, Model::DescribeDrivesResult> DescribeDrivesOutcome;
-			typedef std::future<DescribeDrivesOutcome> DescribeDrivesOutcomeCallable;
-			typedef std::function<void(const EcdClient*, const Model::DescribeDrivesRequest&, const DescribeDrivesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDrivesAsyncHandler;
 			typedef Outcome<Error, Model::DescribeFlowMetricResult> DescribeFlowMetricOutcome;
 			typedef std::future<DescribeFlowMetricOutcome> DescribeFlowMetricOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DescribeFlowMetricRequest&, const DescribeFlowMetricOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFlowMetricAsyncHandler;
@@ -573,6 +685,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeUserConnectionRecordsResult> DescribeUserConnectionRecordsOutcome;
 			typedef std::future<DescribeUserConnectionRecordsOutcome> DescribeUserConnectionRecordsOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DescribeUserConnectionRecordsRequest&, const DescribeUserConnectionRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserConnectionRecordsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeUserProfilePathRulesResult> DescribeUserProfilePathRulesOutcome;
+			typedef std::future<DescribeUserProfilePathRulesOutcome> DescribeUserProfilePathRulesOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::DescribeUserProfilePathRulesRequest&, const DescribeUserProfilePathRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserProfilePathRulesAsyncHandler;
 			typedef Outcome<Error, Model::DescribeUsersInGroupResult> DescribeUsersInGroupOutcome;
 			typedef std::future<DescribeUsersInGroupOutcome> DescribeUsersInGroupOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DescribeUsersInGroupRequest&, const DescribeUsersInGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUsersInGroupAsyncHandler;
@@ -597,6 +712,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DetachCenResult> DetachCenOutcome;
 			typedef std::future<DetachCenOutcome> DetachCenOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DetachCenRequest&, const DetachCenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachCenAsyncHandler;
+			typedef Outcome<Error, Model::DetachEndUserResult> DetachEndUserOutcome;
+			typedef std::future<DetachEndUserOutcome> DetachEndUserOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::DetachEndUserRequest&, const DetachEndUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetachEndUserAsyncHandler;
 			typedef Outcome<Error, Model::DisableDesktopsInGroupResult> DisableDesktopsInGroupOutcome;
 			typedef std::future<DisableDesktopsInGroupOutcome> DisableDesktopsInGroupOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::DisableDesktopsInGroupRequest&, const DisableDesktopsInGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableDesktopsInGroupAsyncHandler;
@@ -627,9 +745,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::HandleSecurityEventsResult> HandleSecurityEventsOutcome;
 			typedef std::future<HandleSecurityEventsOutcome> HandleSecurityEventsOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::HandleSecurityEventsRequest&, const HandleSecurityEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HandleSecurityEventsAsyncHandler;
+			typedef Outcome<Error, Model::HibernateDesktopsResult> HibernateDesktopsOutcome;
+			typedef std::future<HibernateDesktopsOutcome> HibernateDesktopsOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::HibernateDesktopsRequest&, const HibernateDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> HibernateDesktopsAsyncHandler;
+			typedef Outcome<Error, Model::ListCdsFilesResult> ListCdsFilesOutcome;
+			typedef std::future<ListCdsFilesOutcome> ListCdsFilesOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::ListCdsFilesRequest&, const ListCdsFilesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListCdsFilesAsyncHandler;
 			typedef Outcome<Error, Model::ListDirectoryUsersResult> ListDirectoryUsersOutcome;
 			typedef std::future<ListDirectoryUsersOutcome> ListDirectoryUsersOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ListDirectoryUsersRequest&, const ListDirectoryUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListDirectoryUsersAsyncHandler;
+			typedef Outcome<Error, Model::ListFilePermissionResult> ListFilePermissionOutcome;
+			typedef std::future<ListFilePermissionOutcome> ListFilePermissionOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::ListFilePermissionRequest&, const ListFilePermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListFilePermissionAsyncHandler;
 			typedef Outcome<Error, Model::ListOfficeSiteOverviewResult> ListOfficeSiteOverviewOutcome;
 			typedef std::future<ListOfficeSiteOverviewOutcome> ListOfficeSiteOverviewOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ListOfficeSiteOverviewRequest&, const ListOfficeSiteOverviewOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListOfficeSiteOverviewAsyncHandler;
@@ -645,15 +772,30 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::LockVirtualMFADeviceResult> LockVirtualMFADeviceOutcome;
 			typedef std::future<LockVirtualMFADeviceOutcome> LockVirtualMFADeviceOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::LockVirtualMFADeviceRequest&, const LockVirtualMFADeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LockVirtualMFADeviceAsyncHandler;
+			typedef Outcome<Error, Model::MigrateDesktopsResult> MigrateDesktopsOutcome;
+			typedef std::future<MigrateDesktopsOutcome> MigrateDesktopsOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::MigrateDesktopsRequest&, const MigrateDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MigrateDesktopsAsyncHandler;
 			typedef Outcome<Error, Model::ModifyADConnectorDirectoryResult> ModifyADConnectorDirectoryOutcome;
 			typedef std::future<ModifyADConnectorDirectoryOutcome> ModifyADConnectorDirectoryOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ModifyADConnectorDirectoryRequest&, const ModifyADConnectorDirectoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyADConnectorDirectoryAsyncHandler;
 			typedef Outcome<Error, Model::ModifyADConnectorOfficeSiteResult> ModifyADConnectorOfficeSiteOutcome;
 			typedef std::future<ModifyADConnectorOfficeSiteOutcome> ModifyADConnectorOfficeSiteOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ModifyADConnectorOfficeSiteRequest&, const ModifyADConnectorOfficeSiteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyADConnectorOfficeSiteAsyncHandler;
+			typedef Outcome<Error, Model::ModifyAutoSnapshotPolicyResult> ModifyAutoSnapshotPolicyOutcome;
+			typedef std::future<ModifyAutoSnapshotPolicyOutcome> ModifyAutoSnapshotPolicyOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::ModifyAutoSnapshotPolicyRequest&, const ModifyAutoSnapshotPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAutoSnapshotPolicyAsyncHandler;
 			typedef Outcome<Error, Model::ModifyBundleResult> ModifyBundleOutcome;
 			typedef std::future<ModifyBundleOutcome> ModifyBundleOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ModifyBundleRequest&, const ModifyBundleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyBundleAsyncHandler;
+			typedef Outcome<Error, Model::ModifyCdsFileResult> ModifyCdsFileOutcome;
+			typedef std::future<ModifyCdsFileOutcome> ModifyCdsFileOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::ModifyCdsFileRequest&, const ModifyCdsFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCdsFileAsyncHandler;
+			typedef Outcome<Error, Model::ModifyCdsFileShareLinkResult> ModifyCdsFileShareLinkOutcome;
+			typedef std::future<ModifyCdsFileShareLinkOutcome> ModifyCdsFileShareLinkOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::ModifyCdsFileShareLinkRequest&, const ModifyCdsFileShareLinkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCdsFileShareLinkAsyncHandler;
+			typedef Outcome<Error, Model::ModifyCloudDriveGroupsResult> ModifyCloudDriveGroupsOutcome;
+			typedef std::future<ModifyCloudDriveGroupsOutcome> ModifyCloudDriveGroupsOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::ModifyCloudDriveGroupsRequest&, const ModifyCloudDriveGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCloudDriveGroupsAsyncHandler;
 			typedef Outcome<Error, Model::ModifyCloudDrivePermissionResult> ModifyCloudDrivePermissionOutcome;
 			typedef std::future<ModifyCloudDrivePermissionOutcome> ModifyCloudDrivePermissionOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ModifyCloudDrivePermissionRequest&, const ModifyCloudDrivePermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCloudDrivePermissionAsyncHandler;
@@ -720,6 +862,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyUserToDesktopGroupResult> ModifyUserToDesktopGroupOutcome;
 			typedef std::future<ModifyUserToDesktopGroupOutcome> ModifyUserToDesktopGroupOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::ModifyUserToDesktopGroupRequest&, const ModifyUserToDesktopGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyUserToDesktopGroupAsyncHandler;
+			typedef Outcome<Error, Model::MoveCdsFileResult> MoveCdsFileOutcome;
+			typedef std::future<MoveCdsFileOutcome> MoveCdsFileOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::MoveCdsFileRequest&, const MoveCdsFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MoveCdsFileAsyncHandler;
 			typedef Outcome<Error, Model::OperateVulsResult> OperateVulsOutcome;
 			typedef std::future<OperateVulsOutcome> OperateVulsOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::OperateVulsRequest&, const OperateVulsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OperateVulsAsyncHandler;
@@ -729,6 +874,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RebuildDesktopsResult> RebuildDesktopsOutcome;
 			typedef std::future<RebuildDesktopsOutcome> RebuildDesktopsOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::RebuildDesktopsRequest&, const RebuildDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RebuildDesktopsAsyncHandler;
+			typedef Outcome<Error, Model::RemoveFilePermissionResult> RemoveFilePermissionOutcome;
+			typedef std::future<RemoveFilePermissionOutcome> RemoveFilePermissionOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::RemoveFilePermissionRequest&, const RemoveFilePermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveFilePermissionAsyncHandler;
 			typedef Outcome<Error, Model::RemoveUserFromDesktopGroupResult> RemoveUserFromDesktopGroupOutcome;
 			typedef std::future<RemoveUserFromDesktopGroupOutcome> RemoveUserFromDesktopGroupOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::RemoveUserFromDesktopGroupRequest&, const RemoveUserFromDesktopGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveUserFromDesktopGroupAsyncHandler;
@@ -759,18 +907,27 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SendVerifyCodeResult> SendVerifyCodeOutcome;
 			typedef std::future<SendVerifyCodeOutcome> SendVerifyCodeOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::SendVerifyCodeRequest&, const SendVerifyCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SendVerifyCodeAsyncHandler;
+			typedef Outcome<Error, Model::SetDesktopGroupScaleTimerResult> SetDesktopGroupScaleTimerOutcome;
+			typedef std::future<SetDesktopGroupScaleTimerOutcome> SetDesktopGroupScaleTimerOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::SetDesktopGroupScaleTimerRequest&, const SetDesktopGroupScaleTimerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDesktopGroupScaleTimerAsyncHandler;
 			typedef Outcome<Error, Model::SetDesktopGroupTimerResult> SetDesktopGroupTimerOutcome;
 			typedef std::future<SetDesktopGroupTimerOutcome> SetDesktopGroupTimerOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::SetDesktopGroupTimerRequest&, const SetDesktopGroupTimerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDesktopGroupTimerAsyncHandler;
 			typedef Outcome<Error, Model::SetDesktopGroupTimerStatusResult> SetDesktopGroupTimerStatusOutcome;
 			typedef std::future<SetDesktopGroupTimerStatusOutcome> SetDesktopGroupTimerStatusOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::SetDesktopGroupTimerStatusRequest&, const SetDesktopGroupTimerStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDesktopGroupTimerStatusAsyncHandler;
+			typedef Outcome<Error, Model::SetDirectorySsoStatusResult> SetDirectorySsoStatusOutcome;
+			typedef std::future<SetDirectorySsoStatusOutcome> SetDirectorySsoStatusOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::SetDirectorySsoStatusRequest&, const SetDirectorySsoStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDirectorySsoStatusAsyncHandler;
 			typedef Outcome<Error, Model::SetIdpMetadataResult> SetIdpMetadataOutcome;
 			typedef std::future<SetIdpMetadataOutcome> SetIdpMetadataOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::SetIdpMetadataRequest&, const SetIdpMetadataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetIdpMetadataAsyncHandler;
 			typedef Outcome<Error, Model::SetOfficeSiteSsoStatusResult> SetOfficeSiteSsoStatusOutcome;
 			typedef std::future<SetOfficeSiteSsoStatusOutcome> SetOfficeSiteSsoStatusOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::SetOfficeSiteSsoStatusRequest&, const SetOfficeSiteSsoStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetOfficeSiteSsoStatusAsyncHandler;
+			typedef Outcome<Error, Model::SetUserProfilePathRulesResult> SetUserProfilePathRulesOutcome;
+			typedef std::future<SetUserProfilePathRulesOutcome> SetUserProfilePathRulesOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::SetUserProfilePathRulesRequest&, const SetUserProfilePathRulesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetUserProfilePathRulesAsyncHandler;
 			typedef Outcome<Error, Model::StartDesktopsResult> StartDesktopsOutcome;
 			typedef std::future<StartDesktopsOutcome> StartDesktopsOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::StartDesktopsRequest&, const StartDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartDesktopsAsyncHandler;
@@ -801,6 +958,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::VerifyCenResult> VerifyCenOutcome;
 			typedef std::future<VerifyCenOutcome> VerifyCenOutcomeCallable;
 			typedef std::function<void(const EcdClient*, const Model::VerifyCenRequest&, const VerifyCenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> VerifyCenAsyncHandler;
+			typedef Outcome<Error, Model::WakeupDesktopsResult> WakeupDesktopsOutcome;
+			typedef std::future<WakeupDesktopsOutcome> WakeupDesktopsOutcomeCallable;
+			typedef std::function<void(const EcdClient*, const Model::WakeupDesktopsRequest&, const WakeupDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> WakeupDesktopsAsyncHandler;
 
 			EcdClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			EcdClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -809,9 +969,18 @@ namespace AlibabaCloud
 			ActivateOfficeSiteOutcome activateOfficeSite(const Model::ActivateOfficeSiteRequest &request)const;
 			void activateOfficeSiteAsync(const Model::ActivateOfficeSiteRequest& request, const ActivateOfficeSiteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ActivateOfficeSiteOutcomeCallable activateOfficeSiteCallable(const Model::ActivateOfficeSiteRequest& request) const;
+			AddDevicesOutcome addDevices(const Model::AddDevicesRequest &request)const;
+			void addDevicesAsync(const Model::AddDevicesRequest& request, const AddDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddDevicesOutcomeCallable addDevicesCallable(const Model::AddDevicesRequest& request) const;
+			AddFilePermissionOutcome addFilePermission(const Model::AddFilePermissionRequest &request)const;
+			void addFilePermissionAsync(const Model::AddFilePermissionRequest& request, const AddFilePermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddFilePermissionOutcomeCallable addFilePermissionCallable(const Model::AddFilePermissionRequest& request) const;
 			AddUserToDesktopGroupOutcome addUserToDesktopGroup(const Model::AddUserToDesktopGroupRequest &request)const;
 			void addUserToDesktopGroupAsync(const Model::AddUserToDesktopGroupRequest& request, const AddUserToDesktopGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AddUserToDesktopGroupOutcomeCallable addUserToDesktopGroupCallable(const Model::AddUserToDesktopGroupRequest& request) const;
+			ApplyAutoSnapshotPolicyOutcome applyAutoSnapshotPolicy(const Model::ApplyAutoSnapshotPolicyRequest &request)const;
+			void applyAutoSnapshotPolicyAsync(const Model::ApplyAutoSnapshotPolicyRequest& request, const ApplyAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ApplyAutoSnapshotPolicyOutcomeCallable applyAutoSnapshotPolicyCallable(const Model::ApplyAutoSnapshotPolicyRequest& request) const;
 			ApplyCoordinatePrivilegeOutcome applyCoordinatePrivilege(const Model::ApplyCoordinatePrivilegeRequest &request)const;
 			void applyCoordinatePrivilegeAsync(const Model::ApplyCoordinatePrivilegeRequest& request, const ApplyCoordinatePrivilegeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ApplyCoordinatePrivilegeOutcomeCallable applyCoordinatePrivilegeCallable(const Model::ApplyCoordinatePrivilegeRequest& request) const;
@@ -827,6 +996,15 @@ namespace AlibabaCloud
 			AttachCenOutcome attachCen(const Model::AttachCenRequest &request)const;
 			void attachCenAsync(const Model::AttachCenRequest& request, const AttachCenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			AttachCenOutcomeCallable attachCenCallable(const Model::AttachCenRequest& request) const;
+			AttachEndUserOutcome attachEndUser(const Model::AttachEndUserRequest &request)const;
+			void attachEndUserAsync(const Model::AttachEndUserRequest& request, const AttachEndUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AttachEndUserOutcomeCallable attachEndUserCallable(const Model::AttachEndUserRequest& request) const;
+			CancelAutoSnapshotPolicyOutcome cancelAutoSnapshotPolicy(const Model::CancelAutoSnapshotPolicyRequest &request)const;
+			void cancelAutoSnapshotPolicyAsync(const Model::CancelAutoSnapshotPolicyRequest& request, const CancelAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CancelAutoSnapshotPolicyOutcomeCallable cancelAutoSnapshotPolicyCallable(const Model::CancelAutoSnapshotPolicyRequest& request) const;
+			CancelCdsFileShareLinkOutcome cancelCdsFileShareLink(const Model::CancelCdsFileShareLinkRequest &request)const;
+			void cancelCdsFileShareLinkAsync(const Model::CancelCdsFileShareLinkRequest& request, const CancelCdsFileShareLinkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CancelCdsFileShareLinkOutcomeCallable cancelCdsFileShareLinkCallable(const Model::CancelCdsFileShareLinkRequest& request) const;
 			CancelCoordinationForMonitoringOutcome cancelCoordinationForMonitoring(const Model::CancelCoordinationForMonitoringRequest &request)const;
 			void cancelCoordinationForMonitoringAsync(const Model::CancelCoordinationForMonitoringRequest& request, const CancelCoordinationForMonitoringAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CancelCoordinationForMonitoringOutcomeCallable cancelCoordinationForMonitoringCallable(const Model::CancelCoordinationForMonitoringRequest& request) const;
@@ -836,12 +1014,18 @@ namespace AlibabaCloud
 			ClonePolicyGroupOutcome clonePolicyGroup(const Model::ClonePolicyGroupRequest &request)const;
 			void clonePolicyGroupAsync(const Model::ClonePolicyGroupRequest& request, const ClonePolicyGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ClonePolicyGroupOutcomeCallable clonePolicyGroupCallable(const Model::ClonePolicyGroupRequest& request) const;
+			CompleteCdsFileOutcome completeCdsFile(const Model::CompleteCdsFileRequest &request)const;
+			void completeCdsFileAsync(const Model::CompleteCdsFileRequest& request, const CompleteCdsFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CompleteCdsFileOutcomeCallable completeCdsFileCallable(const Model::CompleteCdsFileRequest& request) const;
 			ConfigADConnectorTrustOutcome configADConnectorTrust(const Model::ConfigADConnectorTrustRequest &request)const;
 			void configADConnectorTrustAsync(const Model::ConfigADConnectorTrustRequest& request, const ConfigADConnectorTrustAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ConfigADConnectorTrustOutcomeCallable configADConnectorTrustCallable(const Model::ConfigADConnectorTrustRequest& request) const;
 			ConfigADConnectorUserOutcome configADConnectorUser(const Model::ConfigADConnectorUserRequest &request)const;
 			void configADConnectorUserAsync(const Model::ConfigADConnectorUserRequest& request, const ConfigADConnectorUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ConfigADConnectorUserOutcomeCallable configADConnectorUserCallable(const Model::ConfigADConnectorUserRequest& request) const;
+			CopyCdsFileOutcome copyCdsFile(const Model::CopyCdsFileRequest &request)const;
+			void copyCdsFileAsync(const Model::CopyCdsFileRequest& request, const CopyCdsFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CopyCdsFileOutcomeCallable copyCdsFileCallable(const Model::CopyCdsFileRequest& request) const;
 			CopyImageOutcome copyImage(const Model::CopyImageRequest &request)const;
 			void copyImageAsync(const Model::CopyImageRequest& request, const CopyImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CopyImageOutcomeCallable copyImageCallable(const Model::CopyImageRequest& request) const;
@@ -854,9 +1038,18 @@ namespace AlibabaCloud
 			CreateAndBindNasFileSystemOutcome createAndBindNasFileSystem(const Model::CreateAndBindNasFileSystemRequest &request)const;
 			void createAndBindNasFileSystemAsync(const Model::CreateAndBindNasFileSystemRequest& request, const CreateAndBindNasFileSystemAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateAndBindNasFileSystemOutcomeCallable createAndBindNasFileSystemCallable(const Model::CreateAndBindNasFileSystemRequest& request) const;
+			CreateAutoSnapshotPolicyOutcome createAutoSnapshotPolicy(const Model::CreateAutoSnapshotPolicyRequest &request)const;
+			void createAutoSnapshotPolicyAsync(const Model::CreateAutoSnapshotPolicyRequest& request, const CreateAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAutoSnapshotPolicyOutcomeCallable createAutoSnapshotPolicyCallable(const Model::CreateAutoSnapshotPolicyRequest& request) const;
 			CreateBundleOutcome createBundle(const Model::CreateBundleRequest &request)const;
 			void createBundleAsync(const Model::CreateBundleRequest& request, const CreateBundleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateBundleOutcomeCallable createBundleCallable(const Model::CreateBundleRequest& request) const;
+			CreateCdsFileOutcome createCdsFile(const Model::CreateCdsFileRequest &request)const;
+			void createCdsFileAsync(const Model::CreateCdsFileRequest& request, const CreateCdsFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCdsFileOutcomeCallable createCdsFileCallable(const Model::CreateCdsFileRequest& request) const;
+			CreateCdsFileShareLinkOutcome createCdsFileShareLink(const Model::CreateCdsFileShareLinkRequest &request)const;
+			void createCdsFileShareLinkAsync(const Model::CreateCdsFileShareLinkRequest& request, const CreateCdsFileShareLinkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCdsFileShareLinkOutcomeCallable createCdsFileShareLinkCallable(const Model::CreateCdsFileShareLinkRequest& request) const;
 			CreateDesktopGroupOutcome createDesktopGroup(const Model::CreateDesktopGroupRequest &request)const;
 			void createDesktopGroupAsync(const Model::CreateDesktopGroupRequest& request, const CreateDesktopGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDesktopGroupOutcomeCallable createDesktopGroupCallable(const Model::CreateDesktopGroupRequest& request) const;
@@ -866,9 +1059,6 @@ namespace AlibabaCloud
 			CreateDiskEncryptionServiceOutcome createDiskEncryptionService(const Model::CreateDiskEncryptionServiceRequest &request)const;
 			void createDiskEncryptionServiceAsync(const Model::CreateDiskEncryptionServiceRequest& request, const CreateDiskEncryptionServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateDiskEncryptionServiceOutcomeCallable createDiskEncryptionServiceCallable(const Model::CreateDiskEncryptionServiceRequest& request) const;
-			CreateDriveOutcome createDrive(const Model::CreateDriveRequest &request)const;
-			void createDriveAsync(const Model::CreateDriveRequest& request, const CreateDriveAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			CreateDriveOutcomeCallable createDriveCallable(const Model::CreateDriveRequest& request) const;
 			CreateImageOutcome createImage(const Model::CreateImageRequest &request)const;
 			void createImageAsync(const Model::CreateImageRequest& request, const CreateImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateImageOutcomeCallable createImageCallable(const Model::CreateImageRequest& request) const;
@@ -890,9 +1080,18 @@ namespace AlibabaCloud
 			CreateSnapshotOutcome createSnapshot(const Model::CreateSnapshotRequest &request)const;
 			void createSnapshotAsync(const Model::CreateSnapshotRequest& request, const CreateSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateSnapshotOutcomeCallable createSnapshotCallable(const Model::CreateSnapshotRequest& request) const;
+			DeleteAutoSnapshotPolicyOutcome deleteAutoSnapshotPolicy(const Model::DeleteAutoSnapshotPolicyRequest &request)const;
+			void deleteAutoSnapshotPolicyAsync(const Model::DeleteAutoSnapshotPolicyRequest& request, const DeleteAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteAutoSnapshotPolicyOutcomeCallable deleteAutoSnapshotPolicyCallable(const Model::DeleteAutoSnapshotPolicyRequest& request) const;
 			DeleteBundlesOutcome deleteBundles(const Model::DeleteBundlesRequest &request)const;
 			void deleteBundlesAsync(const Model::DeleteBundlesRequest& request, const DeleteBundlesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteBundlesOutcomeCallable deleteBundlesCallable(const Model::DeleteBundlesRequest& request) const;
+			DeleteCdsFileOutcome deleteCdsFile(const Model::DeleteCdsFileRequest &request)const;
+			void deleteCdsFileAsync(const Model::DeleteCdsFileRequest& request, const DeleteCdsFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteCdsFileOutcomeCallable deleteCdsFileCallable(const Model::DeleteCdsFileRequest& request) const;
+			DeleteCloudDriveGroupsOutcome deleteCloudDriveGroups(const Model::DeleteCloudDriveGroupsRequest &request)const;
+			void deleteCloudDriveGroupsAsync(const Model::DeleteCloudDriveGroupsRequest& request, const DeleteCloudDriveGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteCloudDriveGroupsOutcomeCallable deleteCloudDriveGroupsCallable(const Model::DeleteCloudDriveGroupsRequest& request) const;
 			DeleteCloudDriveUsersOutcome deleteCloudDriveUsers(const Model::DeleteCloudDriveUsersRequest &request)const;
 			void deleteCloudDriveUsersAsync(const Model::DeleteCloudDriveUsersRequest& request, const DeleteCloudDriveUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteCloudDriveUsersOutcomeCallable deleteCloudDriveUsersCallable(const Model::DeleteCloudDriveUsersRequest& request) const;
@@ -902,12 +1101,12 @@ namespace AlibabaCloud
 			DeleteDesktopsOutcome deleteDesktops(const Model::DeleteDesktopsRequest &request)const;
 			void deleteDesktopsAsync(const Model::DeleteDesktopsRequest& request, const DeleteDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDesktopsOutcomeCallable deleteDesktopsCallable(const Model::DeleteDesktopsRequest& request) const;
+			DeleteDevicesOutcome deleteDevices(const Model::DeleteDevicesRequest &request)const;
+			void deleteDevicesAsync(const Model::DeleteDevicesRequest& request, const DeleteDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteDevicesOutcomeCallable deleteDevicesCallable(const Model::DeleteDevicesRequest& request) const;
 			DeleteDirectoriesOutcome deleteDirectories(const Model::DeleteDirectoriesRequest &request)const;
 			void deleteDirectoriesAsync(const Model::DeleteDirectoriesRequest& request, const DeleteDirectoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDirectoriesOutcomeCallable deleteDirectoriesCallable(const Model::DeleteDirectoriesRequest& request) const;
-			DeleteDriveOutcome deleteDrive(const Model::DeleteDriveRequest &request)const;
-			void deleteDriveAsync(const Model::DeleteDriveRequest& request, const DeleteDriveAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DeleteDriveOutcomeCallable deleteDriveCallable(const Model::DeleteDriveRequest& request) const;
 			DeleteImagesOutcome deleteImages(const Model::DeleteImagesRequest &request)const;
 			void deleteImagesAsync(const Model::DeleteImagesRequest& request, const DeleteImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteImagesOutcomeCallable deleteImagesCallable(const Model::DeleteImagesRequest& request) const;
@@ -932,15 +1131,24 @@ namespace AlibabaCloud
 			DescribeAlarmEventStackInfoOutcome describeAlarmEventStackInfo(const Model::DescribeAlarmEventStackInfoRequest &request)const;
 			void describeAlarmEventStackInfoAsync(const Model::DescribeAlarmEventStackInfoRequest& request, const DescribeAlarmEventStackInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeAlarmEventStackInfoOutcomeCallable describeAlarmEventStackInfoCallable(const Model::DescribeAlarmEventStackInfoRequest& request) const;
+			DescribeAutoSnapshotPolicyOutcome describeAutoSnapshotPolicy(const Model::DescribeAutoSnapshotPolicyRequest &request)const;
+			void describeAutoSnapshotPolicyAsync(const Model::DescribeAutoSnapshotPolicyRequest& request, const DescribeAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeAutoSnapshotPolicyOutcomeCallable describeAutoSnapshotPolicyCallable(const Model::DescribeAutoSnapshotPolicyRequest& request) const;
 			DescribeBundlesOutcome describeBundles(const Model::DescribeBundlesRequest &request)const;
 			void describeBundlesAsync(const Model::DescribeBundlesRequest& request, const DescribeBundlesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeBundlesOutcomeCallable describeBundlesCallable(const Model::DescribeBundlesRequest& request) const;
+			DescribeCdsFileShareLinksOutcome describeCdsFileShareLinks(const Model::DescribeCdsFileShareLinksRequest &request)const;
+			void describeCdsFileShareLinksAsync(const Model::DescribeCdsFileShareLinksRequest& request, const DescribeCdsFileShareLinksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeCdsFileShareLinksOutcomeCallable describeCdsFileShareLinksCallable(const Model::DescribeCdsFileShareLinksRequest& request) const;
 			DescribeCensOutcome describeCens(const Model::DescribeCensRequest &request)const;
 			void describeCensAsync(const Model::DescribeCensRequest& request, const DescribeCensAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeCensOutcomeCallable describeCensCallable(const Model::DescribeCensRequest& request) const;
 			DescribeClientEventsOutcome describeClientEvents(const Model::DescribeClientEventsRequest &request)const;
 			void describeClientEventsAsync(const Model::DescribeClientEventsRequest& request, const DescribeClientEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeClientEventsOutcomeCallable describeClientEventsCallable(const Model::DescribeClientEventsRequest& request) const;
+			DescribeCloudDriveGroupsOutcome describeCloudDriveGroups(const Model::DescribeCloudDriveGroupsRequest &request)const;
+			void describeCloudDriveGroupsAsync(const Model::DescribeCloudDriveGroupsRequest& request, const DescribeCloudDriveGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeCloudDriveGroupsOutcomeCallable describeCloudDriveGroupsCallable(const Model::DescribeCloudDriveGroupsRequest& request) const;
 			DescribeCloudDrivePermissionsOutcome describeCloudDrivePermissions(const Model::DescribeCloudDrivePermissionsRequest &request)const;
 			void describeCloudDrivePermissionsAsync(const Model::DescribeCloudDrivePermissionsRequest& request, const DescribeCloudDrivePermissionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeCloudDrivePermissionsOutcomeCallable describeCloudDrivePermissionsCallable(const Model::DescribeCloudDrivePermissionsRequest& request) const;
@@ -962,12 +1170,12 @@ namespace AlibabaCloud
 			DescribeDesktopsInGroupOutcome describeDesktopsInGroup(const Model::DescribeDesktopsInGroupRequest &request)const;
 			void describeDesktopsInGroupAsync(const Model::DescribeDesktopsInGroupRequest& request, const DescribeDesktopsInGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDesktopsInGroupOutcomeCallable describeDesktopsInGroupCallable(const Model::DescribeDesktopsInGroupRequest& request) const;
+			DescribeDevicesOutcome describeDevices(const Model::DescribeDevicesRequest &request)const;
+			void describeDevicesAsync(const Model::DescribeDevicesRequest& request, const DescribeDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDevicesOutcomeCallable describeDevicesCallable(const Model::DescribeDevicesRequest& request) const;
 			DescribeDirectoriesOutcome describeDirectories(const Model::DescribeDirectoriesRequest &request)const;
 			void describeDirectoriesAsync(const Model::DescribeDirectoriesRequest& request, const DescribeDirectoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDirectoriesOutcomeCallable describeDirectoriesCallable(const Model::DescribeDirectoriesRequest& request) const;
-			DescribeDrivesOutcome describeDrives(const Model::DescribeDrivesRequest &request)const;
-			void describeDrivesAsync(const Model::DescribeDrivesRequest& request, const DescribeDrivesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			DescribeDrivesOutcomeCallable describeDrivesCallable(const Model::DescribeDrivesRequest& request) const;
 			DescribeFlowMetricOutcome describeFlowMetric(const Model::DescribeFlowMetricRequest &request)const;
 			void describeFlowMetricAsync(const Model::DescribeFlowMetricRequest& request, const DescribeFlowMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeFlowMetricOutcomeCallable describeFlowMetricCallable(const Model::DescribeFlowMetricRequest& request) const;
@@ -1040,6 +1248,9 @@ namespace AlibabaCloud
 			DescribeUserConnectionRecordsOutcome describeUserConnectionRecords(const Model::DescribeUserConnectionRecordsRequest &request)const;
 			void describeUserConnectionRecordsAsync(const Model::DescribeUserConnectionRecordsRequest& request, const DescribeUserConnectionRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeUserConnectionRecordsOutcomeCallable describeUserConnectionRecordsCallable(const Model::DescribeUserConnectionRecordsRequest& request) const;
+			DescribeUserProfilePathRulesOutcome describeUserProfilePathRules(const Model::DescribeUserProfilePathRulesRequest &request)const;
+			void describeUserProfilePathRulesAsync(const Model::DescribeUserProfilePathRulesRequest& request, const DescribeUserProfilePathRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeUserProfilePathRulesOutcomeCallable describeUserProfilePathRulesCallable(const Model::DescribeUserProfilePathRulesRequest& request) const;
 			DescribeUsersInGroupOutcome describeUsersInGroup(const Model::DescribeUsersInGroupRequest &request)const;
 			void describeUsersInGroupAsync(const Model::DescribeUsersInGroupRequest& request, const DescribeUsersInGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeUsersInGroupOutcomeCallable describeUsersInGroupCallable(const Model::DescribeUsersInGroupRequest& request) const;
@@ -1064,6 +1275,9 @@ namespace AlibabaCloud
 			DetachCenOutcome detachCen(const Model::DetachCenRequest &request)const;
 			void detachCenAsync(const Model::DetachCenRequest& request, const DetachCenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetachCenOutcomeCallable detachCenCallable(const Model::DetachCenRequest& request) const;
+			DetachEndUserOutcome detachEndUser(const Model::DetachEndUserRequest &request)const;
+			void detachEndUserAsync(const Model::DetachEndUserRequest& request, const DetachEndUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetachEndUserOutcomeCallable detachEndUserCallable(const Model::DetachEndUserRequest& request) const;
 			DisableDesktopsInGroupOutcome disableDesktopsInGroup(const Model::DisableDesktopsInGroupRequest &request)const;
 			void disableDesktopsInGroupAsync(const Model::DisableDesktopsInGroupRequest& request, const DisableDesktopsInGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DisableDesktopsInGroupOutcomeCallable disableDesktopsInGroupCallable(const Model::DisableDesktopsInGroupRequest& request) const;
@@ -1094,9 +1308,18 @@ namespace AlibabaCloud
 			HandleSecurityEventsOutcome handleSecurityEvents(const Model::HandleSecurityEventsRequest &request)const;
 			void handleSecurityEventsAsync(const Model::HandleSecurityEventsRequest& request, const HandleSecurityEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			HandleSecurityEventsOutcomeCallable handleSecurityEventsCallable(const Model::HandleSecurityEventsRequest& request) const;
+			HibernateDesktopsOutcome hibernateDesktops(const Model::HibernateDesktopsRequest &request)const;
+			void hibernateDesktopsAsync(const Model::HibernateDesktopsRequest& request, const HibernateDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			HibernateDesktopsOutcomeCallable hibernateDesktopsCallable(const Model::HibernateDesktopsRequest& request) const;
+			ListCdsFilesOutcome listCdsFiles(const Model::ListCdsFilesRequest &request)const;
+			void listCdsFilesAsync(const Model::ListCdsFilesRequest& request, const ListCdsFilesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListCdsFilesOutcomeCallable listCdsFilesCallable(const Model::ListCdsFilesRequest& request) const;
 			ListDirectoryUsersOutcome listDirectoryUsers(const Model::ListDirectoryUsersRequest &request)const;
 			void listDirectoryUsersAsync(const Model::ListDirectoryUsersRequest& request, const ListDirectoryUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListDirectoryUsersOutcomeCallable listDirectoryUsersCallable(const Model::ListDirectoryUsersRequest& request) const;
+			ListFilePermissionOutcome listFilePermission(const Model::ListFilePermissionRequest &request)const;
+			void listFilePermissionAsync(const Model::ListFilePermissionRequest& request, const ListFilePermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListFilePermissionOutcomeCallable listFilePermissionCallable(const Model::ListFilePermissionRequest& request) const;
 			ListOfficeSiteOverviewOutcome listOfficeSiteOverview(const Model::ListOfficeSiteOverviewRequest &request)const;
 			void listOfficeSiteOverviewAsync(const Model::ListOfficeSiteOverviewRequest& request, const ListOfficeSiteOverviewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListOfficeSiteOverviewOutcomeCallable listOfficeSiteOverviewCallable(const Model::ListOfficeSiteOverviewRequest& request) const;
@@ -1112,15 +1335,30 @@ namespace AlibabaCloud
 			LockVirtualMFADeviceOutcome lockVirtualMFADevice(const Model::LockVirtualMFADeviceRequest &request)const;
 			void lockVirtualMFADeviceAsync(const Model::LockVirtualMFADeviceRequest& request, const LockVirtualMFADeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			LockVirtualMFADeviceOutcomeCallable lockVirtualMFADeviceCallable(const Model::LockVirtualMFADeviceRequest& request) const;
+			MigrateDesktopsOutcome migrateDesktops(const Model::MigrateDesktopsRequest &request)const;
+			void migrateDesktopsAsync(const Model::MigrateDesktopsRequest& request, const MigrateDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			MigrateDesktopsOutcomeCallable migrateDesktopsCallable(const Model::MigrateDesktopsRequest& request) const;
 			ModifyADConnectorDirectoryOutcome modifyADConnectorDirectory(const Model::ModifyADConnectorDirectoryRequest &request)const;
 			void modifyADConnectorDirectoryAsync(const Model::ModifyADConnectorDirectoryRequest& request, const ModifyADConnectorDirectoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyADConnectorDirectoryOutcomeCallable modifyADConnectorDirectoryCallable(const Model::ModifyADConnectorDirectoryRequest& request) const;
 			ModifyADConnectorOfficeSiteOutcome modifyADConnectorOfficeSite(const Model::ModifyADConnectorOfficeSiteRequest &request)const;
 			void modifyADConnectorOfficeSiteAsync(const Model::ModifyADConnectorOfficeSiteRequest& request, const ModifyADConnectorOfficeSiteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyADConnectorOfficeSiteOutcomeCallable modifyADConnectorOfficeSiteCallable(const Model::ModifyADConnectorOfficeSiteRequest& request) const;
+			ModifyAutoSnapshotPolicyOutcome modifyAutoSnapshotPolicy(const Model::ModifyAutoSnapshotPolicyRequest &request)const;
+			void modifyAutoSnapshotPolicyAsync(const Model::ModifyAutoSnapshotPolicyRequest& request, const ModifyAutoSnapshotPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyAutoSnapshotPolicyOutcomeCallable modifyAutoSnapshotPolicyCallable(const Model::ModifyAutoSnapshotPolicyRequest& request) const;
 			ModifyBundleOutcome modifyBundle(const Model::ModifyBundleRequest &request)const;
 			void modifyBundleAsync(const Model::ModifyBundleRequest& request, const ModifyBundleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyBundleOutcomeCallable modifyBundleCallable(const Model::ModifyBundleRequest& request) const;
+			ModifyCdsFileOutcome modifyCdsFile(const Model::ModifyCdsFileRequest &request)const;
+			void modifyCdsFileAsync(const Model::ModifyCdsFileRequest& request, const ModifyCdsFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyCdsFileOutcomeCallable modifyCdsFileCallable(const Model::ModifyCdsFileRequest& request) const;
+			ModifyCdsFileShareLinkOutcome modifyCdsFileShareLink(const Model::ModifyCdsFileShareLinkRequest &request)const;
+			void modifyCdsFileShareLinkAsync(const Model::ModifyCdsFileShareLinkRequest& request, const ModifyCdsFileShareLinkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyCdsFileShareLinkOutcomeCallable modifyCdsFileShareLinkCallable(const Model::ModifyCdsFileShareLinkRequest& request) const;
+			ModifyCloudDriveGroupsOutcome modifyCloudDriveGroups(const Model::ModifyCloudDriveGroupsRequest &request)const;
+			void modifyCloudDriveGroupsAsync(const Model::ModifyCloudDriveGroupsRequest& request, const ModifyCloudDriveGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyCloudDriveGroupsOutcomeCallable modifyCloudDriveGroupsCallable(const Model::ModifyCloudDriveGroupsRequest& request) const;
 			ModifyCloudDrivePermissionOutcome modifyCloudDrivePermission(const Model::ModifyCloudDrivePermissionRequest &request)const;
 			void modifyCloudDrivePermissionAsync(const Model::ModifyCloudDrivePermissionRequest& request, const ModifyCloudDrivePermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyCloudDrivePermissionOutcomeCallable modifyCloudDrivePermissionCallable(const Model::ModifyCloudDrivePermissionRequest& request) const;
@@ -1187,6 +1425,9 @@ namespace AlibabaCloud
 			ModifyUserToDesktopGroupOutcome modifyUserToDesktopGroup(const Model::ModifyUserToDesktopGroupRequest &request)const;
 			void modifyUserToDesktopGroupAsync(const Model::ModifyUserToDesktopGroupRequest& request, const ModifyUserToDesktopGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyUserToDesktopGroupOutcomeCallable modifyUserToDesktopGroupCallable(const Model::ModifyUserToDesktopGroupRequest& request) const;
+			MoveCdsFileOutcome moveCdsFile(const Model::MoveCdsFileRequest &request)const;
+			void moveCdsFileAsync(const Model::MoveCdsFileRequest& request, const MoveCdsFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			MoveCdsFileOutcomeCallable moveCdsFileCallable(const Model::MoveCdsFileRequest& request) const;
 			OperateVulsOutcome operateVuls(const Model::OperateVulsRequest &request)const;
 			void operateVulsAsync(const Model::OperateVulsRequest& request, const OperateVulsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			OperateVulsOutcomeCallable operateVulsCallable(const Model::OperateVulsRequest& request) const;
@@ -1196,6 +1437,9 @@ namespace AlibabaCloud
 			RebuildDesktopsOutcome rebuildDesktops(const Model::RebuildDesktopsRequest &request)const;
 			void rebuildDesktopsAsync(const Model::RebuildDesktopsRequest& request, const RebuildDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RebuildDesktopsOutcomeCallable rebuildDesktopsCallable(const Model::RebuildDesktopsRequest& request) const;
+			RemoveFilePermissionOutcome removeFilePermission(const Model::RemoveFilePermissionRequest &request)const;
+			void removeFilePermissionAsync(const Model::RemoveFilePermissionRequest& request, const RemoveFilePermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveFilePermissionOutcomeCallable removeFilePermissionCallable(const Model::RemoveFilePermissionRequest& request) const;
 			RemoveUserFromDesktopGroupOutcome removeUserFromDesktopGroup(const Model::RemoveUserFromDesktopGroupRequest &request)const;
 			void removeUserFromDesktopGroupAsync(const Model::RemoveUserFromDesktopGroupRequest& request, const RemoveUserFromDesktopGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RemoveUserFromDesktopGroupOutcomeCallable removeUserFromDesktopGroupCallable(const Model::RemoveUserFromDesktopGroupRequest& request) const;
@@ -1226,18 +1470,27 @@ namespace AlibabaCloud
 			SendVerifyCodeOutcome sendVerifyCode(const Model::SendVerifyCodeRequest &request)const;
 			void sendVerifyCodeAsync(const Model::SendVerifyCodeRequest& request, const SendVerifyCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SendVerifyCodeOutcomeCallable sendVerifyCodeCallable(const Model::SendVerifyCodeRequest& request) const;
+			SetDesktopGroupScaleTimerOutcome setDesktopGroupScaleTimer(const Model::SetDesktopGroupScaleTimerRequest &request)const;
+			void setDesktopGroupScaleTimerAsync(const Model::SetDesktopGroupScaleTimerRequest& request, const SetDesktopGroupScaleTimerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetDesktopGroupScaleTimerOutcomeCallable setDesktopGroupScaleTimerCallable(const Model::SetDesktopGroupScaleTimerRequest& request) const;
 			SetDesktopGroupTimerOutcome setDesktopGroupTimer(const Model::SetDesktopGroupTimerRequest &request)const;
 			void setDesktopGroupTimerAsync(const Model::SetDesktopGroupTimerRequest& request, const SetDesktopGroupTimerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetDesktopGroupTimerOutcomeCallable setDesktopGroupTimerCallable(const Model::SetDesktopGroupTimerRequest& request) const;
 			SetDesktopGroupTimerStatusOutcome setDesktopGroupTimerStatus(const Model::SetDesktopGroupTimerStatusRequest &request)const;
 			void setDesktopGroupTimerStatusAsync(const Model::SetDesktopGroupTimerStatusRequest& request, const SetDesktopGroupTimerStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetDesktopGroupTimerStatusOutcomeCallable setDesktopGroupTimerStatusCallable(const Model::SetDesktopGroupTimerStatusRequest& request) const;
+			SetDirectorySsoStatusOutcome setDirectorySsoStatus(const Model::SetDirectorySsoStatusRequest &request)const;
+			void setDirectorySsoStatusAsync(const Model::SetDirectorySsoStatusRequest& request, const SetDirectorySsoStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetDirectorySsoStatusOutcomeCallable setDirectorySsoStatusCallable(const Model::SetDirectorySsoStatusRequest& request) const;
 			SetIdpMetadataOutcome setIdpMetadata(const Model::SetIdpMetadataRequest &request)const;
 			void setIdpMetadataAsync(const Model::SetIdpMetadataRequest& request, const SetIdpMetadataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetIdpMetadataOutcomeCallable setIdpMetadataCallable(const Model::SetIdpMetadataRequest& request) const;
 			SetOfficeSiteSsoStatusOutcome setOfficeSiteSsoStatus(const Model::SetOfficeSiteSsoStatusRequest &request)const;
 			void setOfficeSiteSsoStatusAsync(const Model::SetOfficeSiteSsoStatusRequest& request, const SetOfficeSiteSsoStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetOfficeSiteSsoStatusOutcomeCallable setOfficeSiteSsoStatusCallable(const Model::SetOfficeSiteSsoStatusRequest& request) const;
+			SetUserProfilePathRulesOutcome setUserProfilePathRules(const Model::SetUserProfilePathRulesRequest &request)const;
+			void setUserProfilePathRulesAsync(const Model::SetUserProfilePathRulesRequest& request, const SetUserProfilePathRulesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetUserProfilePathRulesOutcomeCallable setUserProfilePathRulesCallable(const Model::SetUserProfilePathRulesRequest& request) const;
 			StartDesktopsOutcome startDesktops(const Model::StartDesktopsRequest &request)const;
 			void startDesktopsAsync(const Model::StartDesktopsRequest& request, const StartDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartDesktopsOutcomeCallable startDesktopsCallable(const Model::StartDesktopsRequest& request) const;
@@ -1268,6 +1521,9 @@ namespace AlibabaCloud
 			VerifyCenOutcome verifyCen(const Model::VerifyCenRequest &request)const;
 			void verifyCenAsync(const Model::VerifyCenRequest& request, const VerifyCenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			VerifyCenOutcomeCallable verifyCenCallable(const Model::VerifyCenRequest& request) const;
+			WakeupDesktopsOutcome wakeupDesktops(const Model::WakeupDesktopsRequest &request)const;
+			void wakeupDesktopsAsync(const Model::WakeupDesktopsRequest& request, const WakeupDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			WakeupDesktopsOutcomeCallable wakeupDesktopsCallable(const Model::WakeupDesktopsRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

ecd/include/alibabacloud/ecd/model/AddDevicesRequest.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ECD_MODEL_DESCRIBEDRIVESREQUEST_H_
+#ifndef ALIBABACLOUD_ECD_MODEL_ADDDEVICESREQUEST_H_
-#define ALIBABACLOUD_ECD_MODEL_DESCRIBEDRIVESREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_ADDDEVICESREQUEST_H_
 
 #include <alibabacloud/ecd/EcdExport.h>
 #include <alibabacloud/core/RpcServiceRequest.h>
@@ -26,26 +26,23 @@
 namespace AlibabaCloud {
 namespace Ecd {
 namespace Model {
-class ALIBABACLOUD_ECD_EXPORT DescribeDrivesRequest : public RpcServiceRequest {
+class ALIBABACLOUD_ECD_EXPORT AddDevicesRequest : public RpcServiceRequest {
 public:
-	DescribeDrivesRequest();
+	AddDevicesRequest();
-	~DescribeDrivesRequest();
+	~AddDevicesRequest();
-	std::string getUserId() const;
+	int getClientType() const;
-	void setUserId(const std::string &userId);
+	void setClientType(int clientType);
-	std::string getResourceType() const;
+	std::vector<std::string> getDeviceIds() const;
-	void setResourceType(const std::string &resourceType);
+	void setDeviceIds(const std::vector<std::string> &deviceIds);
-	std::vector<std::string> getDomainIds() const;
-	void setDomainIds(const std::vector<std::string> &domainIds);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 
 private:
-	std::string userId_;
+	int clientType_;
-	std::string resourceType_;
+	std::vector<std::string> deviceIds_;
-	std::vector<std::string> domainIds_;
 	std::string regionId_;
 };
 } // namespace Model
 } // namespace Ecd
 } // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_ECD_MODEL_DESCRIBEDRIVESREQUEST_H_
+#endif // !ALIBABACLOUD_ECD_MODEL_ADDDEVICESREQUEST_H_

ecd/include/alibabacloud/ecd/model/AddDevicesResult.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_ECD_MODEL_ADDDEVICESRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_ADDDEVICESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT AddDevicesResult : public ServiceResult
+			{
+			public:
+
+
+				AddDevicesResult();
+				explicit AddDevicesResult(const std::string &payload);
+				~AddDevicesResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_ADDDEVICESRESULT_H_

ecd/include/alibabacloud/ecd/model/AddFilePermissionRequest.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECD_MODEL_ADDFILEPERMISSIONREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_ADDFILEPERMISSIONREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT AddFilePermissionRequest : public RpcServiceRequest {
+public:
+	struct MemberList {
+		long expireTime;
+		std::string roleId;
+		struct CdsIdentity {
+			std::string id;
+			std::string type;
+		};
+		CdsIdentity cdsIdentity;
+		bool disinheritSubGroup;
+	};
+	AddFilePermissionRequest();
+	~AddFilePermissionRequest();
+	std::vector<MemberList> getMemberList() const;
+	void setMemberList(const std::vector<MemberList> &memberList);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	std::string getFileId() const;
+	void setFileId(const std::string &fileId);
+
+private:
+	std::vector<MemberList> memberList_;
+	std::string cdsId_;
+	std::string regionId_;
+	std::string endUserId_;
+	std::string fileId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_ADDFILEPERMISSIONREQUEST_H_

ecd/include/alibabacloud/ecd/model/AddFilePermissionResult.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_ECD_MODEL_ADDFILEPERMISSIONRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_ADDFILEPERMISSIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT AddFilePermissionResult : public ServiceResult
+			{
+			public:
+
+
+				AddFilePermissionResult();
+				explicit AddFilePermissionResult(const std::string &payload);
+				~AddFilePermissionResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_ADDFILEPERMISSIONRESULT_H_

ecd/include/alibabacloud/ecd/model/ApplyAutoSnapshotPolicyRequest.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_ECD_MODEL_APPLYAUTOSNAPSHOTPOLICYREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_APPLYAUTOSNAPSHOTPOLICYREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT ApplyAutoSnapshotPolicyRequest : public RpcServiceRequest {
+public:
+	ApplyAutoSnapshotPolicyRequest();
+	~ApplyAutoSnapshotPolicyRequest();
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getDesktopId() const;
+	void setDesktopId(const std::vector<std::string> &desktopId);
+
+private:
+	std::string policyId_;
+	std::string regionId_;
+	std::vector<std::string> desktopId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_APPLYAUTOSNAPSHOTPOLICYREQUEST_H_

ecd/include/alibabacloud/ecd/model/ApplyAutoSnapshotPolicyResult.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_ECD_MODEL_APPLYAUTOSNAPSHOTPOLICYRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_APPLYAUTOSNAPSHOTPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT ApplyAutoSnapshotPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				ApplyAutoSnapshotPolicyResult();
+				explicit ApplyAutoSnapshotPolicyResult(const std::string &payload);
+				~ApplyAutoSnapshotPolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_APPLYAUTOSNAPSHOTPOLICYRESULT_H_

ecd/include/alibabacloud/ecd/model/AttachEndUserRequest.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_ECD_MODEL_ATTACHENDUSERREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_ATTACHENDUSERREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT AttachEndUserRequest : public RpcServiceRequest {
+public:
+	AttachEndUserRequest();
+	~AttachEndUserRequest();
+	int getClientType() const;
+	void setClientType(int clientType);
+	std::string getUserType() const;
+	void setUserType(const std::string &userType);
+	std::string getDeviceId() const;
+	void setDeviceId(const std::string &deviceId);
+	std::string getAdDomain() const;
+	void setAdDomain(const std::string &adDomain);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	std::string getDirectoryId() const;
+	void setDirectoryId(const std::string &directoryId);
+
+private:
+	int clientType_;
+	std::string userType_;
+	std::string deviceId_;
+	std::string adDomain_;
+	std::string regionId_;
+	std::string endUserId_;
+	std::string directoryId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_ATTACHENDUSERREQUEST_H_

ecd/include/alibabacloud/ecd/model/AttachEndUserResult.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_ECD_MODEL_ATTACHENDUSERRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_ATTACHENDUSERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT AttachEndUserResult : public ServiceResult
+			{
+			public:
+
+
+				AttachEndUserResult();
+				explicit AttachEndUserResult(const std::string &payload);
+				~AttachEndUserResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_ATTACHENDUSERRESULT_H_

ecd/include/alibabacloud/ecd/model/CancelAutoSnapshotPolicyRequest.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_ECD_MODEL_CANCELAUTOSNAPSHOTPOLICYREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_CANCELAUTOSNAPSHOTPOLICYREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT CancelAutoSnapshotPolicyRequest : public RpcServiceRequest {
+public:
+	CancelAutoSnapshotPolicyRequest();
+	~CancelAutoSnapshotPolicyRequest();
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getDesktopId() const;
+	void setDesktopId(const std::vector<std::string> &desktopId);
+
+private:
+	std::string policyId_;
+	std::string regionId_;
+	std::vector<std::string> desktopId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_CANCELAUTOSNAPSHOTPOLICYREQUEST_H_

ecd/include/alibabacloud/ecd/model/CancelAutoSnapshotPolicyResult.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_ECD_MODEL_CANCELAUTOSNAPSHOTPOLICYRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_CANCELAUTOSNAPSHOTPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT CancelAutoSnapshotPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				CancelAutoSnapshotPolicyResult();
+				explicit CancelAutoSnapshotPolicyResult(const std::string &payload);
+				~CancelAutoSnapshotPolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_CANCELAUTOSNAPSHOTPOLICYRESULT_H_

ecd/include/alibabacloud/ecd/model/CancelCdsFileShareLinkRequest.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_ECD_MODEL_CANCELCDSFILESHARELINKREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_CANCELCDSFILESHARELINKREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT CancelCdsFileShareLinkRequest : public RpcServiceRequest {
+public:
+	CancelCdsFileShareLinkRequest();
+	~CancelCdsFileShareLinkRequest();
+	std::string getShareId() const;
+	void setShareId(const std::string &shareId);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+
+private:
+	std::string shareId_;
+	std::string cdsId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_CANCELCDSFILESHARELINKREQUEST_H_

ecd/include/alibabacloud/ecd/model/CancelCdsFileShareLinkResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ECD_MODEL_DELETEDRIVERESULT_H_
+#ifndef ALIBABACLOUD_ECD_MODEL_CANCELCDSFILESHARELINKRESULT_H_
-#define ALIBABACLOUD_ECD_MODEL_DELETEDRIVERESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_CANCELCDSFILESHARELINKRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_ECD_EXPORT DeleteDriveResult : public ServiceResult
+			class ALIBABACLOUD_ECD_EXPORT CancelCdsFileShareLinkResult : public ServiceResult
 			{
 			public:
 
 
-				DeleteDriveResult();
+				CancelCdsFileShareLinkResult();
-				explicit DeleteDriveResult(const std::string &payload);
+				explicit CancelCdsFileShareLinkResult(const std::string &payload);
-				~DeleteDriveResult();
+				~CancelCdsFileShareLinkResult();
 				std::string getMessage()const;
 				bool getData()const;
 				std::string getCode()const;
@@ -54,4 +54,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ECD_MODEL_DELETEDRIVERESULT_H_
+#endif // !ALIBABACLOUD_ECD_MODEL_CANCELCDSFILESHARELINKRESULT_H_

ecd/include/alibabacloud/ecd/model/CompleteCdsFileRequest.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_ECD_MODEL_COMPLETECDSFILEREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_COMPLETECDSFILEREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT CompleteCdsFileRequest : public RpcServiceRequest {
+public:
+	CompleteCdsFileRequest();
+	~CompleteCdsFileRequest();
+	std::string getUploadId() const;
+	void setUploadId(const std::string &uploadId);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	std::string getFileId() const;
+	void setFileId(const std::string &fileId);
+
+private:
+	std::string uploadId_;
+	std::string cdsId_;
+	std::string regionId_;
+	std::string endUserId_;
+	std::string fileId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_COMPLETECDSFILEREQUEST_H_

ecd/include/alibabacloud/ecd/model/CompleteCdsFileResult.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_ECD_MODEL_COMPLETECDSFILERESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_COMPLETECDSFILERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT CompleteCdsFileResult : public ServiceResult
+			{
+			public:
+
+
+				CompleteCdsFileResult();
+				explicit CompleteCdsFileResult(const std::string &payload);
+				~CompleteCdsFileResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_COMPLETECDSFILERESULT_H_

ecd/include/alibabacloud/ecd/model/ConfigADConnectorTrustRequest.h

@@ -36,11 +36,14 @@ public:
 	void setTrustKey(const std::string &trustKey);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
+	bool getRdsLicenseDomain() const;
+	void setRdsLicenseDomain(bool rdsLicenseDomain);
 
 private:
 	std::string officeSiteId_;
 	std::string trustKey_;
 	std::string regionId_;
+	bool rdsLicenseDomain_;
 };
 } // namespace Model
 } // namespace Ecd

ecd/include/alibabacloud/ecd/model/CopyCdsFileRequest.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_ECD_MODEL_COPYCDSFILEREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_COPYCDSFILEREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT CopyCdsFileRequest : public RpcServiceRequest {
+public:
+	CopyCdsFileRequest();
+	~CopyCdsFileRequest();
+	bool getAutoRename() const;
+	void setAutoRename(bool autoRename);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getParentFolderId() const;
+	void setParentFolderId(const std::string &parentFolderId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	std::string getFileId() const;
+	void setFileId(const std::string &fileId);
+
+private:
+	bool autoRename_;
+	std::string cdsId_;
+	std::string parentFolderId_;
+	std::string regionId_;
+	std::string endUserId_;
+	std::string fileId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_COPYCDSFILEREQUEST_H_

ecd/include/alibabacloud/ecd/model/CopyCdsFileResult.h

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

ecd/include/alibabacloud/ecd/model/CreateAutoSnapshotPolicyRequest.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_ECD_MODEL_CREATEAUTOSNAPSHOTPOLICYREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_CREATEAUTOSNAPSHOTPOLICYREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT CreateAutoSnapshotPolicyRequest : public RpcServiceRequest {
+public:
+	CreateAutoSnapshotPolicyRequest();
+	~CreateAutoSnapshotPolicyRequest();
+	std::string getCronExpression() const;
+	void setCronExpression(const std::string &cronExpression);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getPolicyName() const;
+	void setPolicyName(const std::string &policyName);
+	int getRetentionDays() const;
+	void setRetentionDays(int retentionDays);
+
+private:
+	std::string cronExpression_;
+	std::string regionId_;
+	std::string policyName_;
+	int retentionDays_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_CREATEAUTOSNAPSHOTPOLICYREQUEST_H_

ecd/include/alibabacloud/ecd/model/CreateAutoSnapshotPolicyResult.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_ECD_MODEL_CREATEAUTOSNAPSHOTPOLICYRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_CREATEAUTOSNAPSHOTPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT CreateAutoSnapshotPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				CreateAutoSnapshotPolicyResult();
+				explicit CreateAutoSnapshotPolicyResult(const std::string &payload);
+				~CreateAutoSnapshotPolicyResult();
+				std::string getPolicyId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string policyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_CREATEAUTOSNAPSHOTPOLICYRESULT_H_

ecd/include/alibabacloud/ecd/model/CreateCdsFileRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECD_MODEL_CREATECDSFILEREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_CREATECDSFILEREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT CreateCdsFileRequest : public RpcServiceRequest {
+public:
+	CreateCdsFileRequest();
+	~CreateCdsFileRequest();
+	std::string getFileType() const;
+	void setFileType(const std::string &fileType);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getConflictPolicy() const;
+	void setConflictPolicy(const std::string &conflictPolicy);
+	std::string getParentFileId() const;
+	void setParentFileId(const std::string &parentFileId);
+	std::string getFileName() const;
+	void setFileName(const std::string &fileName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getFileLength() const;
+	void setFileLength(long fileLength);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	std::string getFileHash() const;
+	void setFileHash(const std::string &fileHash);
+
+private:
+	std::string fileType_;
+	std::string cdsId_;
+	std::string conflictPolicy_;
+	std::string parentFileId_;
+	std::string fileName_;
+	std::string regionId_;
+	long fileLength_;
+	std::string endUserId_;
+	std::string fileHash_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_CREATECDSFILEREQUEST_H_

ecd/include/alibabacloud/ecd/model/CreateCdsFileResult.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_ECD_MODEL_CREATECDSFILERESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_CREATECDSFILERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT CreateCdsFileResult : public ServiceResult
+			{
+			public:
+				struct FileModel
+				{
+					std::string uploadUrl;
+					std::string fileId;
+					std::string uploadId;
+				};
+
+
+				CreateCdsFileResult();
+				explicit CreateCdsFileResult(const std::string &payload);
+				~CreateCdsFileResult();
+				FileModel getFileModel()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				FileModel fileModel_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_CREATECDSFILERESULT_H_

ecd/include/alibabacloud/ecd/model/CreateCdsFileShareLinkRequest.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECD_MODEL_CREATECDSFILESHARELINKREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_CREATECDSFILESHARELINKREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT CreateCdsFileShareLinkRequest : public RpcServiceRequest {
+public:
+	CreateCdsFileShareLinkRequest();
+	~CreateCdsFileShareLinkRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	long getPreviewLimit() const;
+	void setPreviewLimit(long previewLimit);
+	bool getDisableDownload() const;
+	void setDisableDownload(bool disableDownload);
+	bool getDisablePreview() const;
+	void setDisablePreview(bool disablePreview);
+	std::string getSharePwd() const;
+	void setSharePwd(const std::string &sharePwd);
+	std::string getShareName() const;
+	void setShareName(const std::string &shareName);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	bool getDisableSave() const;
+	void setDisableSave(bool disableSave);
+	long getDownloadLimit() const;
+	void setDownloadLimit(long downloadLimit);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	long getSaveLimit() const;
+	void setSaveLimit(long saveLimit);
+	std::vector<std::string> getFileIds() const;
+	void setFileIds(const std::vector<std::string> &fileIds);
+	std::string getExpiration() const;
+	void setExpiration(const std::string &expiration);
+
+private:
+	std::string description_;
+	long previewLimit_;
+	bool disableDownload_;
+	bool disablePreview_;
+	std::string sharePwd_;
+	std::string shareName_;
+	std::string endUserId_;
+	bool disableSave_;
+	long downloadLimit_;
+	std::string cdsId_;
+	long saveLimit_;
+	std::vector<std::string> fileIds_;
+	std::string expiration_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_CREATECDSFILESHARELINKREQUEST_H_

ecd/include/alibabacloud/ecd/model/CreateCdsFileShareLinkResult.h

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_ECD_MODEL_DESCRIBEDRIVESRESULT_H_
+#ifndef ALIBABACLOUD_ECD_MODEL_CREATECDSFILESHARELINKRESULT_H_
-#define ALIBABACLOUD_ECD_MODEL_DESCRIBEDRIVESRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_CREATECDSFILESHARELINKRESULT_H_
 
 #include <string>
 #include <vector>
@@ -29,44 +29,44 @@ namespace AlibabaCloud
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_ECD_EXPORT DescribeDrivesResult : public ServiceResult
+			class ALIBABACLOUD_ECD_EXPORT CreateCdsFileShareLinkResult : public ServiceResult
 			{
 			public:
-				struct Drive
+				struct Data
 				{
-					struct DesktopGroup
+					long previewCount;
-					{
-						std::string desktopGroupId;
-						std::string desktopGroupName;
-					};
-					std::string status;
 					std::string description;
-					bool enableProfileManagement;
+					long saveLimit;
-					std::vector<Drive::DesktopGroup> desktopGroups;
+					long downloadLimit;
-					bool profileRoaming;
+					std::string shareName;
-					std::string gmtModified;
 					std::string driveId;
-					std::string externalDriveId;
+					std::string creator;
-					long totalSize;
+					bool disablePreview;
-					long usedSize;
+					long videoPreviewCount;
-					std::string name;
+					std::string shareId;
-					std::string externalDomainId;
+					bool disableDownload;
-					std::string gmtCreate;
+					std::string status;
-					std::string type;
+					std::string createTime;
-					std::string domainId;
+					std::string expiration;
-					int desktopGroupCount;
+					bool expired;
-					std::string userId;
+					long saveCount;
-					std::string externalUserId;
+					std::string modifiyTime;
-					std::string id;
+					long reportCount;
-					long aliUid;
+					long previewLimit;
+					bool disableSave;
+					std::string sharePwd;
+					std::string shareLink;
+					std::string fileIds;
+					long downloadCount;
+					long accessCount;
 				};
 
 
-				DescribeDrivesResult();
+				CreateCdsFileShareLinkResult();
-				explicit DescribeDrivesResult(const std::string &payload);
+				explicit CreateCdsFileShareLinkResult(const std::string &payload);
-				~DescribeDrivesResult();
+				~CreateCdsFileShareLinkResult();
 				std::string getMessage()const;
-				std::vector<Drive> getDrives()const;
+				Data getData()const;
 				std::string getCode()const;
 				bool getSuccess()const;
 
@@ -74,7 +74,7 @@ namespace AlibabaCloud
 				void parse(const std::string &payload);
 			private:
 				std::string message_;
-				std::vector<Drive> drives_;
+				Data data_;
 				std::string code_;
 				bool success_;
 
@@ -82,4 +82,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_ECD_MODEL_DESCRIBEDRIVESRESULT_H_
+#endif // !ALIBABACLOUD_ECD_MODEL_CREATECDSFILESHARELINKRESULT_H_

ecd/include/alibabacloud/ecd/model/CreateDesktopGroupRequest.h

@@ -34,6 +34,8 @@ public:
 	void setDesktopGroupName(const std::string &desktopGroupName);
 	int getAllowBufferCount() const;
 	void setAllowBufferCount(int allowBufferCount);
+	int getGroupVersion() const;
+	void setGroupVersion(int groupVersion);
 	bool getAllClassifyUsers() const;
 	void setAllClassifyUsers(bool allClassifyUsers);
 	int getMaxDesktopsCount() const;
@@ -52,8 +54,12 @@ public:
 	void setKeepDuration(long keepDuration);
 	std::string getPeriodUnit() const;
 	void setPeriodUnit(const std::string &periodUnit);
+	bool getAutoRenew() const;
+	void setAutoRenew(bool autoRenew);
 	bool getProfileFollowSwitch() const;
 	void setProfileFollowSwitch(bool profileFollowSwitch);
+	int getBuyDesktopsCount() const;
+	void setBuyDesktopsCount(int buyDesktopsCount);
 	std::string getPolicyGroupId() const;
 	void setPolicyGroupId(const std::string &policyGroupId);
 	std::string getVolumeEncryptionKey() const;
@@ -104,6 +110,7 @@ public:
 private:
 	std::string desktopGroupName_;
 	int allowBufferCount_;
+	int groupVersion_;
 	bool allClassifyUsers_;
 	int maxDesktopsCount_;
 	bool volumeEncryptionEnabled_;
@@ -113,7 +120,9 @@ private:
 	float ratioThreshold_;
 	long keepDuration_;
 	std::string periodUnit_;
+	bool autoRenew_;
 	bool profileFollowSwitch_;
+	int buyDesktopsCount_;
 	std::string policyGroupId_;
 	std::string volumeEncryptionKey_;
 	std::string officeSiteId_;

ecd/include/alibabacloud/ecd/model/CreateDesktopsRequest.h

@@ -28,10 +28,27 @@ namespace Ecd {
 namespace Model {
 class ALIBABACLOUD_ECD_EXPORT CreateDesktopsRequest : public RpcServiceRequest {
 public:
+	struct DesktopTimers {
+		std::string cronExpression;
+		std::string timerType;
+		bool allowClientSetting;
+		std::string resetType;
+		bool enforce;
+		int interval;
+		std::string operationType;
+	};
 	struct Tag {
 		std::string value;
 		std::string key;
 	};
+	struct BundleModels {
+		bool volumeEncryptionEnabled;
+		std::string volumeEncryptionKey;
+		int amount;
+		std::string desktopName;
+		std::string hostname;
+		std::string bundleId;
+	};
 	struct UserCommands {
 		std::string contentEncoding;
 		std::string content;
@@ -51,6 +68,8 @@ public:
 	void setUserAssignMode(const std::string &userAssignMode);
 	std::string getHostname() const;
 	void setHostname(const std::string &hostname);
+	std::vector<DesktopTimers> getDesktopTimers() const;
+	void setDesktopTimers(const std::vector<DesktopTimers> &desktopTimers);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	bool getDesktopNameSuffix() const;
@@ -61,8 +80,12 @@ public:
 	void setDirectoryId(const std::string &directoryId);
 	std::vector<std::string> getEndUserId() const;
 	void setEndUserId(const std::vector<std::string> &endUserId);
+	std::string getDesktopMemberIp() const;
+	void setDesktopMemberIp(const std::string &desktopMemberIp);
 	std::vector<Tag> getTag() const;
 	void setTag(const std::vector<Tag> &tag);
+	std::vector<BundleModels> getBundleModels() const;
+	void setBundleModels(const std::vector<BundleModels> &bundleModels);
 	bool getVolumeEncryptionEnabled() const;
 	void setVolumeEncryptionEnabled(bool volumeEncryptionEnabled);
 	std::string getDesktopName() const;
@@ -103,12 +126,15 @@ private:
 	std::string bundleId_;
 	std::string userAssignMode_;
 	std::string hostname_;
+	std::vector<DesktopTimers> desktopTimers_;
 	std::string regionId_;
 	bool desktopNameSuffix_;
 	std::string systemDiskSize_;
 	std::string directoryId_;
 	std::vector<std::string> endUserId_;
+	std::string desktopMemberIp_;
 	std::vector<Tag> tag_;
+	std::vector<BundleModels> bundleModels_;
 	bool volumeEncryptionEnabled_;
 	std::string desktopName_;
 	int amount_;

ecd/include/alibabacloud/ecd/model/CreateDriveRequest.h

@@ -1,75 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ALIBABACLOUD_ECD_MODEL_CREATEDRIVEREQUEST_H_
-#define ALIBABACLOUD_ECD_MODEL_CREATEDRIVEREQUEST_H_
-
-#include <alibabacloud/ecd/EcdExport.h>
-#include <alibabacloud/core/RpcServiceRequest.h>
-#include <string>
-#include <vector>
-#include <map>
-
-namespace AlibabaCloud {
-namespace Ecd {
-namespace Model {
-class ALIBABACLOUD_ECD_EXPORT CreateDriveRequest : public RpcServiceRequest {
-public:
-	CreateDriveRequest();
-	~CreateDriveRequest();
-	bool getProfileRoaming() const;
-	void setProfileRoaming(bool profileRoaming);
-	std::string getDescription() const;
-	void setDescription(const std::string &description);
-	std::string getType() const;
-	void setType(const std::string &type);
-	std::string getUserId() const;
-	void setUserId(const std::string &userId);
-	std::string getDomainId() const;
-	void setDomainId(const std::string &domainId);
-	std::string getRegionId() const;
-	void setRegionId(const std::string &regionId);
-	std::string getExternalDomainId() const;
-	void setExternalDomainId(const std::string &externalDomainId);
-	long getUsedSize() const;
-	void setUsedSize(long usedSize);
-	long getAliUid() const;
-	void setAliUid(long aliUid);
-	std::string getDriveName() const;
-	void setDriveName(const std::string &driveName);
-	long getTotalSize() const;
-	void setTotalSize(long totalSize);
-	std::string getResourceType() const;
-	void setResourceType(const std::string &resourceType);
-
-private:
-	bool profileRoaming_;
-	std::string description_;
-	std::string type_;
-	std::string userId_;
-	std::string domainId_;
-	std::string regionId_;
-	std::string externalDomainId_;
-	long usedSize_;
-	long aliUid_;
-	std::string driveName_;
-	long totalSize_;
-	std::string resourceType_;
-};
-} // namespace Model
-} // namespace Ecd
-} // namespace AlibabaCloud
-#endif // !ALIBABACLOUD_ECD_MODEL_CREATEDRIVEREQUEST_H_

ecd/include/alibabacloud/ecd/model/CreateNetworkPackageRequest.h

@@ -32,6 +32,8 @@ public:
 	~CreateNetworkPackageRequest();
 	std::string getOfficeSiteId() const;
 	void setOfficeSiteId(const std::string &officeSiteId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
 	int getPeriod() const;
 	void setPeriod(int period);
 	bool getAutoPay() const;
@@ -44,21 +46,22 @@ public:
 	void setPeriodUnit(const std::string &periodUnit);
 	bool getAutoRenew() const;
 	void setAutoRenew(bool autoRenew);
-	std::string getRegionId() const;
-	void setRegionId(const std::string &regionId);
 	std::string getInternetChargeType() const;
 	void setInternetChargeType(const std::string &internetChargeType);
+	std::string getPayType() const;
+	void setPayType(const std::string &payType);
 
 private:
 	std::string officeSiteId_;
+	std::string regionId_;
 	int period_;
 	bool autoPay_;
 	int bandwidth_;
 	std::string promotionId_;
 	std::string periodUnit_;
 	bool autoRenew_;
-	std::string regionId_;
 	std::string internetChargeType_;
+	std::string payType_;
 };
 } // namespace Model
 } // namespace Ecd

ecd/include/alibabacloud/ecd/model/CreatePolicyGroupRequest.h

@@ -28,6 +28,29 @@ namespace Ecd {
 namespace Model {
 class ALIBABACLOUD_ECD_EXPORT CreatePolicyGroupRequest : public RpcServiceRequest {
 public:
+	struct AuthorizeSecurityPolicyRule {
+		std::string portRange;
+		std::string ipProtocol;
+		std::string description;
+		std::string type;
+		std::string priority;
+		std::string cidrIp;
+		std::string policy;
+	};
+	struct NetRedirectRule {
+		std::string ruleType;
+		std::string domain;
+		std::string policy;
+	};
+	struct DomainResolveRule {
+		std::string domain;
+		std::string description;
+		std::string policy;
+	};
+	struct AuthorizeAccessPolicyRule {
+		std::string description;
+		std::string cidrIp;
+	};
 	struct ClientType {
 		std::string clientType;
 		std::string status;
@@ -41,31 +64,10 @@ public:
 		std::string deviceClass;
 		long usbRuleType;
 	};
-	struct AuthorizeSecurityPolicyRule {
-		std::string portRange;
-		std::string ipProtocol;
-		std::string description;
-		std::string type;
-		std::string priority;
-		std::string cidrIp;
-		std::string policy;
-	};
-	struct AuthorizeAccessPolicyRule {
-		std::string description;
-		std::string cidrIp;
-	};
 	CreatePolicyGroupRequest();
 	~CreatePolicyGroupRequest();
-	std::string getWatermarkCustomText() const;
-	void setWatermarkCustomText(const std::string &watermarkCustomText);
-	std::string getPreemptLogin() const;
-	void setPreemptLogin(const std::string &preemptLogin);
 	long getRecordingExpires() const;
 	void setRecordingExpires(long recordingExpires);
-	std::vector<ClientType> getClientType() const;
-	void setClientType(const std::vector<ClientType> &clientType);
-	std::vector<UsbSupplyRedirectRule> getUsbSupplyRedirectRule() const;
-	void setUsbSupplyRedirectRule(const std::vector<UsbSupplyRedirectRule> &usbSupplyRedirectRule);
 	std::string getPrinterRedirection() const;
 	void setPrinterRedirection(const std::string &printerRedirection);
 	std::vector<std::string> getPreemptLoginUser() const;
@@ -76,84 +78,179 @@ public:
 	void setNetRedirect(const std::string &netRedirect);
 	std::string getLocalDrive() const;
 	void setLocalDrive(const std::string &localDrive);
+	int getWatermarkTransparencyValue() const;
+	void setWatermarkTransparencyValue(int watermarkTransparencyValue);
 	std::vector<AuthorizeSecurityPolicyRule> getAuthorizeSecurityPolicyRule() const;
 	void setAuthorizeSecurityPolicyRule(const std::vector<AuthorizeSecurityPolicyRule> &authorizeSecurityPolicyRule);
-	std::string getRecording() const;
-	void setRecording(const std::string &recording);
 	std::string getClipboard() const;
 	void setClipboard(const std::string &clipboard);
-	long getRecordingFps() const;
+	std::string getEndUserApplyAdminCoordinate() const;
-	void setRecordingFps(long recordingFps);
+	void setEndUserApplyAdminCoordinate(const std::string &endUserApplyAdminCoordinate);
 	std::string getUsbRedirect() const;
 	void setUsbRedirect(const std::string &usbRedirect);
-	std::string getRegionId() const;
-	void setRegionId(const std::string &regionId);
 	std::string getWatermarkType() const;
 	void setWatermarkType(const std::string &watermarkType);
 	std::string getRecordingStartTime() const;
 	void setRecordingStartTime(const std::string &recordingStartTime);
-	std::string getRecordContent() const;
+	std::vector<NetRedirectRule> getNetRedirectRule() const;
-	void setRecordContent(const std::string &recordContent);
+	void setNetRedirectRule(const std::vector<NetRedirectRule> &netRedirectRule);
-	long getRecordContentExpires() const;
+	int getRecordingDuration() const;
-	void setRecordContentExpires(long recordContentExpires);
+	void setRecordingDuration(int recordingDuration);
+	int getWatermarkColor() const;
+	void setWatermarkColor(int watermarkColor);
+	int getMemoryRateLimit() const;
+	void setMemoryRateLimit(int memoryRateLimit);
 	std::string getWatermark() const;
 	void setWatermark(const std::string &watermark);
 	std::string getCameraRedirect() const;
 	void setCameraRedirect(const std::string &cameraRedirect);
+	std::vector<std::string> getMemoryProcessors() const;
+	void setMemoryProcessors(const std::vector<std::string> &memoryProcessors);
+	std::string getVideoRedirect() const;
+	void setVideoRedirect(const std::string &videoRedirect);
+	int getCpuSingleRateLimit() const;
+	void setCpuSingleRateLimit(int cpuSingleRateLimit);
+	std::string getAppContentProtection() const;
+	void setAppContentProtection(const std::string &appContentProtection);
+	std::string getCpuProtectedMode() const;
+	void setCpuProtectedMode(const std::string &cpuProtectedMode);
+	std::vector<DomainResolveRule> getDomainResolveRule() const;
+	void setDomainResolveRule(const std::vector<DomainResolveRule> &domainResolveRule);
+	std::vector<AuthorizeAccessPolicyRule> getAuthorizeAccessPolicyRule() const;
+	void setAuthorizeAccessPolicyRule(const std::vector<AuthorizeAccessPolicyRule> &authorizeAccessPolicyRule);
+	std::string getWatermarkTransparency() const;
+	void setWatermarkTransparency(const std::string &watermarkTransparency);
+	std::string getName() const;
+	void setName(const std::string &name);
+	int getMemorySampleDuration() const;
+	void setMemorySampleDuration(int memorySampleDuration);
+	std::string getWatermarkCustomText() const;
+	void setWatermarkCustomText(const std::string &watermarkCustomText);
+	int getCpuDownGradeDuration() const;
+	void setCpuDownGradeDuration(int cpuDownGradeDuration);
+	std::string getPreemptLogin() const;
+	void setPreemptLogin(const std::string &preemptLogin);
+	std::vector<ClientType> getClientType() const;
+	void setClientType(const std::vector<ClientType> &clientType);
+	std::vector<UsbSupplyRedirectRule> getUsbSupplyRedirectRule() const;
+	void setUsbSupplyRedirectRule(const std::vector<UsbSupplyRedirectRule> &usbSupplyRedirectRule);
+	int getWatermarkFontSize() const;
+	void setWatermarkFontSize(int watermarkFontSize);
+	std::string getRecording() const;
+	void setRecording(const std::string &recording);
+	std::vector<std::string> getScopeValue() const;
+	void setScopeValue(const std::vector<std::string> &scopeValue);
+	std::string getDomainResolveRuleType() const;
+	void setDomainResolveRuleType(const std::string &domainResolveRuleType);
+	int getMemorySingleRateLimit() const;
+	void setMemorySingleRateLimit(int memorySingleRateLimit);
+	long getRecordingFps() const;
+	void setRecordingFps(long recordingFps);
+	std::string getWatermarkFontStyle() const;
+	void setWatermarkFontStyle(const std::string &watermarkFontStyle);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getRecordContent() const;
+	void setRecordContent(const std::string &recordContent);
+	std::string getScope() const;
+	void setScope(const std::string &scope);
+	int getWatermarkRowAmount() const;
+	void setWatermarkRowAmount(int watermarkRowAmount);
+	std::vector<std::string> getCpuProcessors() const;
+	void setCpuProcessors(const std::vector<std::string> &cpuProcessors);
+	std::string getEndUserGroupCoordinate() const;
+	void setEndUserGroupCoordinate(const std::string &endUserGroupCoordinate);
+	double getWatermarkDegree() const;
+	void setWatermarkDegree(double watermarkDegree);
+	long getRecordContentExpires() const;
+	void setRecordContentExpires(long recordContentExpires);
+	std::string getRecordingAudio() const;
+	void setRecordingAudio(const std::string &recordingAudio);
+	int getCpuRateLimit() const;
+	void setCpuRateLimit(int cpuRateLimit);
 	std::string getRemoteCoordinate() const;
 	void setRemoteCoordinate(const std::string &remoteCoordinate);
+	int getCpuSampleDuration() const;
+	void setCpuSampleDuration(int cpuSampleDuration);
 	std::string getHtml5Access() const;
 	void setHtml5Access(const std::string &html5Access);
 	std::string getGpuAcceleration() const;
 	void setGpuAcceleration(const std::string &gpuAcceleration);
 	std::string getHtml5FileTransfer() const;
 	void setHtml5FileTransfer(const std::string &html5FileTransfer);
-	std::string getAppContentProtection() const;
-	void setAppContentProtection(const std::string &appContentProtection);
-	std::vector<AuthorizeAccessPolicyRule> getAuthorizeAccessPolicyRule() const;
-	void setAuthorizeAccessPolicyRule(const std::vector<AuthorizeAccessPolicyRule> &authorizeAccessPolicyRule);
 	std::string getVisualQuality() const;
 	void setVisualQuality(const std::string &visualQuality);
-	std::string getWatermarkTransparency() const;
-	void setWatermarkTransparency(const std::string &watermarkTransparency);
-	std::string getName() const;
-	void setName(const std::string &name);
 	std::string getRecordingEndTime() const;
 	void setRecordingEndTime(const std::string &recordingEndTime);
+	std::string getMemoryProtectedMode() const;
+	void setMemoryProtectedMode(const std::string &memoryProtectedMode);
+	int getMemoryDownGradeDuration() const;
+	void setMemoryDownGradeDuration(int memoryDownGradeDuration);
+	std::string getInternetCommunicationProtocol() const;
+	void setInternetCommunicationProtocol(const std::string &internetCommunicationProtocol);
 
 private:
-	std::string watermarkCustomText_;
-	std::string preemptLogin_;
 	long recordingExpires_;
-	std::vector<ClientType> clientType_;
-	std::vector<UsbSupplyRedirectRule> usbSupplyRedirectRule_;
 	std::string printerRedirection_;
 	std::vector<std::string> preemptLoginUser_;
 	std::string domainList_;
 	std::string netRedirect_;
 	std::string localDrive_;
+	int watermarkTransparencyValue_;
 	std::vector<AuthorizeSecurityPolicyRule> authorizeSecurityPolicyRule_;
-	std::string recording_;
 	std::string clipboard_;
-	long recordingFps_;
+	std::string endUserApplyAdminCoordinate_;
 	std::string usbRedirect_;
-	std::string regionId_;
 	std::string watermarkType_;
 	std::string recordingStartTime_;
-	std::string recordContent_;
+	std::vector<NetRedirectRule> netRedirectRule_;
-	long recordContentExpires_;
+	int recordingDuration_;
+	int watermarkColor_;
+	int memoryRateLimit_;
 	std::string watermark_;
 	std::string cameraRedirect_;
+	std::vector<std::string> memoryProcessors_;
+	std::string videoRedirect_;
+	int cpuSingleRateLimit_;
+	std::string appContentProtection_;
+	std::string cpuProtectedMode_;
+	std::vector<DomainResolveRule> domainResolveRule_;
+	std::vector<AuthorizeAccessPolicyRule> authorizeAccessPolicyRule_;
+	std::string watermarkTransparency_;
+	std::string name_;
+	int memorySampleDuration_;
+	std::string watermarkCustomText_;
+	int cpuDownGradeDuration_;
+	std::string preemptLogin_;
+	std::vector<ClientType> clientType_;
+	std::vector<UsbSupplyRedirectRule> usbSupplyRedirectRule_;
+	int watermarkFontSize_;
+	std::string recording_;
+	std::vector<std::string> scopeValue_;
+	std::string domainResolveRuleType_;
+	int memorySingleRateLimit_;
+	long recordingFps_;
+	std::string watermarkFontStyle_;
+	std::string regionId_;
+	std::string recordContent_;
+	std::string scope_;
+	int watermarkRowAmount_;
+	std::vector<std::string> cpuProcessors_;
+	std::string endUserGroupCoordinate_;
+	double watermarkDegree_;
+	long recordContentExpires_;
+	std::string recordingAudio_;
+	int cpuRateLimit_;
 	std::string remoteCoordinate_;
+	int cpuSampleDuration_;
 	std::string html5Access_;
 	std::string gpuAcceleration_;
 	std::string html5FileTransfer_;
-	std::string appContentProtection_;
-	std::vector<AuthorizeAccessPolicyRule> authorizeAccessPolicyRule_;
 	std::string visualQuality_;
-	std::string watermarkTransparency_;
-	std::string name_;
 	std::string recordingEndTime_;
+	std::string memoryProtectedMode_;
+	int memoryDownGradeDuration_;
+	std::string internetCommunicationProtocol_;
 };
 } // namespace Model
 } // namespace Ecd

ecd/include/alibabacloud/ecd/model/CreateSimpleOfficeSiteRequest.h

@@ -30,6 +30,8 @@ class ALIBABACLOUD_ECD_EXPORT CreateSimpleOfficeSiteRequest : public RpcServiceR
 public:
 	CreateSimpleOfficeSiteRequest();
 	~CreateSimpleOfficeSiteRequest();
+	std::string getVpcType() const;
+	void setVpcType(const std::string &vpcType);
 	std::string getCenId() const;
 	void setCenId(const std::string &cenId);
 	long getCenOwnerId() const;
@@ -58,6 +60,7 @@ public:
 	void setCidrBlock(const std::string &cidrBlock);
 
 private:
+	std::string vpcType_;
 	std::string cenId_;
 	long cenOwnerId_;
 	bool enableInternetAccess_;

ecd/include/alibabacloud/ecd/model/DeleteAutoSnapshotPolicyRequest.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_ECD_MODEL_DELETEAUTOSNAPSHOTPOLICYREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_DELETEAUTOSNAPSHOTPOLICYREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT DeleteAutoSnapshotPolicyRequest : public RpcServiceRequest {
+public:
+	DeleteAutoSnapshotPolicyRequest();
+	~DeleteAutoSnapshotPolicyRequest();
+	std::vector<std::string> getPolicyId() const;
+	void setPolicyId(const std::vector<std::string> &policyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::vector<std::string> policyId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_DELETEAUTOSNAPSHOTPOLICYREQUEST_H_

ecd/include/alibabacloud/ecd/model/DeleteAutoSnapshotPolicyResult.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_ECD_MODEL_DELETEAUTOSNAPSHOTPOLICYRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_DELETEAUTOSNAPSHOTPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT DeleteAutoSnapshotPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteAutoSnapshotPolicyResult();
+				explicit DeleteAutoSnapshotPolicyResult(const std::string &payload);
+				~DeleteAutoSnapshotPolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_DELETEAUTOSNAPSHOTPOLICYRESULT_H_

ecd/include/alibabacloud/ecd/model/DeleteCdsFileRequest.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_ECD_MODEL_DELETECDSFILEREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_DELETECDSFILEREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT DeleteCdsFileRequest : public RpcServiceRequest {
+public:
+	DeleteCdsFileRequest();
+	~DeleteCdsFileRequest();
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	std::string getFileId() const;
+	void setFileId(const std::string &fileId);
+
+private:
+	std::string cdsId_;
+	std::string regionId_;
+	std::string endUserId_;
+	std::string fileId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_DELETECDSFILEREQUEST_H_

ecd/include/alibabacloud/ecd/model/DeleteCdsFileResult.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_ECD_MODEL_DELETECDSFILERESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_DELETECDSFILERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT DeleteCdsFileResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteCdsFileResult();
+				explicit DeleteCdsFileResult(const std::string &payload);
+				~DeleteCdsFileResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_DELETECDSFILERESULT_H_

ecd/include/alibabacloud/ecd/model/DeleteCloudDriveGroupsRequest.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_ECD_MODEL_DELETECLOUDDRIVEGROUPSREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_DELETECLOUDDRIVEGROUPSREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT DeleteCloudDriveGroupsRequest : public RpcServiceRequest {
+public:
+	DeleteCloudDriveGroupsRequest();
+	~DeleteCloudDriveGroupsRequest();
+	std::vector<std::string> getGroupId() const;
+	void setGroupId(const std::vector<std::string> &groupId);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::vector<std::string> groupId_;
+	std::string cdsId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_DELETECLOUDDRIVEGROUPSREQUEST_H_

ecd/include/alibabacloud/ecd/model/DeleteCloudDriveGroupsResult.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_ECD_MODEL_DELETECLOUDDRIVEGROUPSRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_DELETECLOUDDRIVEGROUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT DeleteCloudDriveGroupsResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteCloudDriveGroupsResult();
+				explicit DeleteCloudDriveGroupsResult(const std::string &payload);
+				~DeleteCloudDriveGroupsResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_DELETECLOUDDRIVEGROUPSRESULT_H_

ecd/include/alibabacloud/ecd/model/DeleteDevicesRequest.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_ECD_MODEL_DELETEDEVICESREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_DELETEDEVICESREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT DeleteDevicesRequest : public RpcServiceRequest {
+public:
+	DeleteDevicesRequest();
+	~DeleteDevicesRequest();
+	int getClientType() const;
+	void setClientType(int clientType);
+	std::vector<std::string> getDeviceIds() const;
+	void setDeviceIds(const std::vector<std::string> &deviceIds);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	int getForce() const;
+	void setForce(int force);
+
+private:
+	int clientType_;
+	std::vector<std::string> deviceIds_;
+	std::string regionId_;
+	int force_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_DELETEDEVICESREQUEST_H_

ecd/include/alibabacloud/ecd/model/DeleteDevicesResult.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_ECD_MODEL_DELETEDEVICESRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_DELETEDEVICESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT DeleteDevicesResult : public ServiceResult
+			{
+			public:
+
+
+				DeleteDevicesResult();
+				explicit DeleteDevicesResult(const std::string &payload);
+				~DeleteDevicesResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_DELETEDEVICESRESULT_H_

ecd/include/alibabacloud/ecd/model/DeleteImagesRequest.h

@@ -34,10 +34,13 @@ public:
 	void setImageId(const std::vector<std::string> &imageId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
+	bool getDeleteCascadedBundle() const;
+	void setDeleteCascadedBundle(bool deleteCascadedBundle);
 
 private:
 	std::vector<std::string> imageId_;
 	std::string regionId_;
+	bool deleteCascadedBundle_;
 };
 } // namespace Model
 } // namespace Ecd

ecd/include/alibabacloud/ecd/model/DescribeAutoSnapshotPolicyRequest.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_ECD_MODEL_DESCRIBEAUTOSNAPSHOTPOLICYREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_DESCRIBEAUTOSNAPSHOTPOLICYREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT DescribeAutoSnapshotPolicyRequest : public RpcServiceRequest {
+public:
+	DescribeAutoSnapshotPolicyRequest();
+	~DescribeAutoSnapshotPolicyRequest();
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getPolicyName() const;
+	void setPolicyName(const std::string &policyName);
+
+private:
+	std::string policyId_;
+	std::string regionId_;
+	std::string nextToken_;
+	int maxResults_;
+	std::string policyName_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_DESCRIBEAUTOSNAPSHOTPOLICYREQUEST_H_

ecd/include/alibabacloud/ecd/model/DescribeAutoSnapshotPolicyResult.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_ECD_MODEL_DESCRIBEAUTOSNAPSHOTPOLICYRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_DESCRIBEAUTOSNAPSHOTPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT DescribeAutoSnapshotPolicyResult : public ServiceResult
+			{
+			public:
+				struct AutoSnapshotPolicy
+				{
+					std::string status;
+					std::string timePoints;
+					std::string policyName;
+					std::string creationTime;
+					std::string retentionDays;
+					std::string cronExpression;
+					std::string regionId;
+					int desktopNum;
+					std::string policyId;
+				};
+
+
+				DescribeAutoSnapshotPolicyResult();
+				explicit DescribeAutoSnapshotPolicyResult(const std::string &payload);
+				~DescribeAutoSnapshotPolicyResult();
+				std::string getNextToken()const;
+				std::vector<AutoSnapshotPolicy> getAutoSnapshotPolicies()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::vector<AutoSnapshotPolicy> autoSnapshotPolicies_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_DESCRIBEAUTOSNAPSHOTPOLICYRESULT_H_

ecd/include/alibabacloud/ecd/model/DescribeBundlesRequest.h

@@ -32,10 +32,14 @@ public:
 	~DescribeBundlesRequest();
 	float getGpuCount() const;
 	void setGpuCount(float gpuCount);
+	std::vector<std::string> getImageId() const;
+	void setImageId(const std::vector<std::string> &imageId);
 	std::vector<std::string> getBundleId() const;
 	void setBundleId(const std::vector<std::string> &bundleId);
 	std::string getDesktopTypeFamily() const;
 	void setDesktopTypeFamily(const std::string &desktopTypeFamily);
+	bool getSelectedBundle() const;
+	void setSelectedBundle(bool selectedBundle);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string getNextToken() const;
@@ -50,6 +54,10 @@ public:
 	void setVolumeEncryptionEnabled(bool volumeEncryptionEnabled);
 	int getMemorySize() const;
 	void setMemorySize(int memorySize);
+	std::string getSessionType() const;
+	void setSessionType(const std::string &sessionType);
+	std::string getOsType() const;
+	void setOsType(const std::string &osType);
 	int getMaxResults() const;
 	void setMaxResults(int maxResults);
 	bool getCheckStock() const;
@@ -63,8 +71,10 @@ public:
 
 private:
 	float gpuCount_;
+	std::vector<std::string> imageId_;
 	std::vector<std::string> bundleId_;
 	std::string desktopTypeFamily_;
+	bool selectedBundle_;
 	std::string regionId_;
 	std::string nextToken_;
 	bool fromDesktopGroup_;
@@ -72,6 +82,8 @@ private:
 	std::string fotaChannel_;
 	bool volumeEncryptionEnabled_;
 	int memorySize_;
+	std::string sessionType_;
+	std::string osType_;
 	int maxResults_;
 	bool checkStock_;
 	std::string protocolType_;

ecd/include/alibabacloud/ecd/model/DescribeBundlesResult.h

@@ -51,6 +51,7 @@ namespace AlibabaCloud
 					std::string sessionType;
 					std::string description;
 					std::string platform;
+					std::string imageStatus;
 					std::string bundleName;
 					bool volumeEncryptionEnabled;
 					std::string imageName;

ecd/include/alibabacloud/ecd/model/DescribeCdsFileShareLinksRequest.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_ECD_MODEL_DESCRIBECDSFILESHARELINKSREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_DESCRIBECDSFILESHARELINKSREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT DescribeCdsFileShareLinksRequest : public RpcServiceRequest {
+public:
+	DescribeCdsFileShareLinksRequest();
+	~DescribeCdsFileShareLinksRequest();
+	std::vector<std::string> getCreators() const;
+	void setCreators(const std::vector<std::string> &creators);
+	std::string getShareId() const;
+	void setShareId(const std::string &shareId);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getShareName() const;
+	void setShareName(const std::string &shareName);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	std::vector<std::string> creators_;
+	std::string shareId_;
+	std::string cdsId_;
+	std::string shareName_;
+	std::string nextToken_;
+	int maxResults_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_DESCRIBECDSFILESHARELINKSREQUEST_H_

ecd/include/alibabacloud/ecd/model/DescribeCdsFileShareLinksResult.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECD_MODEL_DESCRIBECDSFILESHARELINKSRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_DESCRIBECDSFILESHARELINKSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT DescribeCdsFileShareLinksResult : public ServiceResult
+			{
+			public:
+				struct CdsFileShareLinkModel
+				{
+					long previewCount;
+					std::string description;
+					long saveLimit;
+					long downloadLimit;
+					std::string shareName;
+					std::string driveId;
+					std::string creator;
+					bool disablePreview;
+					long videoPreviewCount;
+					std::string shareId;
+					bool disableDownload;
+					std::string status;
+					std::string createTime;
+					std::string expiration;
+					bool expired;
+					long saveCount;
+					std::string modifiyTime;
+					long reportCount;
+					long previewLimit;
+					bool disableSave;
+					std::string sharePwd;
+					std::string shareLink;
+					std::string fileIds;
+					long downloadCount;
+					long accessCount;
+				};
+
+
+				DescribeCdsFileShareLinksResult();
+				explicit DescribeCdsFileShareLinksResult(const std::string &payload);
+				~DescribeCdsFileShareLinksResult();
+				std::string getNextToken()const;
+				std::string getMessage()const;
+				std::vector<CdsFileShareLinkModel> getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string message_;
+				std::vector<CdsFileShareLinkModel> data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_DESCRIBECDSFILESHARELINKSRESULT_H_

ecd/include/alibabacloud/ecd/model/DescribeCloudDriveGroupsRequest.h

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECD_MODEL_DESCRIBECLOUDDRIVEGROUPSREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_DESCRIBECLOUDDRIVEGROUPSREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT DescribeCloudDriveGroupsRequest : public RpcServiceRequest {
+public:
+	DescribeCloudDriveGroupsRequest();
+	~DescribeCloudDriveGroupsRequest();
+	std::string getParentGroupId() const;
+	void setParentGroupId(const std::string &parentGroupId);
+	std::string getGroupType() const;
+	void setGroupType(const std::string &groupType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getDriveType() const;
+	void setDriveType(const std::string &driveType);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getDirectoryId() const;
+	void setDirectoryId(const std::string &directoryId);
+	std::vector<std::string> getGroupId() const;
+	void setGroupId(const std::vector<std::string> &groupId);
+	std::string getDirectoryName() const;
+	void setDirectoryName(const std::string &directoryName);
+	std::string getGroupName() const;
+	void setGroupName(const std::string &groupName);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getDriveStatus() const;
+	void setDriveStatus(const std::string &driveStatus);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	std::string parentGroupId_;
+	std::string groupType_;
+	std::string regionId_;
+	std::string driveType_;
+	std::string nextToken_;
+	std::string directoryId_;
+	std::vector<std::string> groupId_;
+	std::string directoryName_;
+	std::string groupName_;
+	std::string cdsId_;
+	std::string driveStatus_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_DESCRIBECLOUDDRIVEGROUPSREQUEST_H_

ecd/include/alibabacloud/ecd/model/DescribeCloudDriveGroupsResult.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECD_MODEL_DESCRIBECLOUDDRIVEGROUPSRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_DESCRIBECLOUDDRIVEGROUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT DescribeCloudDriveGroupsResult : public ServiceResult
+			{
+			public:
+				struct CloudDriveGroup
+				{
+					std::string status;
+					std::string groupName;
+					std::string directoryId;
+					std::string createTime;
+					std::string driveId;
+					long totalSize;
+					std::string usedSize;
+					std::string groupId;
+				};
+
+
+				DescribeCloudDriveGroupsResult();
+				explicit DescribeCloudDriveGroupsResult(const std::string &payload);
+				~DescribeCloudDriveGroupsResult();
+				std::string getNextToken()const;
+				long getCount()const;
+				std::vector<CloudDriveGroup> getCloudDriveGroups()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				long count_;
+				std::vector<CloudDriveGroup> cloudDriveGroups_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_DESCRIBECLOUDDRIVEGROUPSRESULT_H_

ecd/include/alibabacloud/ecd/model/DescribeDesktopGroupsRequest.h

@@ -34,6 +34,10 @@ public:
 	void setOfficeSiteId(const std::string &officeSiteId);
 	std::vector<std::string> getEndUserIds() const;
 	void setEndUserIds(const std::vector<std::string> &endUserIds);
+	std::vector<std::string> getImageId() const;
+	void setImageId(const std::vector<std::string> &imageId);
+	std::vector<std::string> getBundleId() const;
+	void setBundleId(const std::vector<std::string> &bundleId);
 	std::string getDesktopGroupName() const;
 	void setDesktopGroupName(const std::string &desktopGroupName);
 	std::string getDesktopGroupId() const;
@@ -52,6 +56,8 @@ public:
 	void setPeriodUnit(const std::string &periodUnit);
 	int getMaxResults() const;
 	void setMaxResults(int maxResults);
+	std::string getProtocolType() const;
+	void setProtocolType(const std::string &protocolType);
 	std::string getPolicyGroupId() const;
 	void setPolicyGroupId(const std::string &policyGroupId);
 	int getStatus() const;
@@ -60,6 +66,8 @@ public:
 private:
 	std::string officeSiteId_;
 	std::vector<std::string> endUserIds_;
+	std::vector<std::string> imageId_;
+	std::vector<std::string> bundleId_;
 	std::string desktopGroupName_;
 	std::string desktopGroupId_;
 	std::string regionId_;
@@ -69,6 +77,7 @@ private:
 	std::vector<std::string> excludedEndUserIds_;
 	std::string periodUnit_;
 	int maxResults_;
+	std::string protocolType_;
 	std::string policyGroupId_;
 	int status_;
 };

ecd/include/alibabacloud/ecd/model/DescribeDesktopGroupsResult.h

@@ -47,6 +47,7 @@ namespace AlibabaCloud
 					long ownType;
 					long loadPolicy;
 					int version;
+					std::string osType;
 					long keepDuration;
 					std::string expiredTime;
 					int maxDesktopsCount;
@@ -73,8 +74,10 @@ namespace AlibabaCloud
 					std::string directoryId;
 					std::string gpuSpec;
 					long stopDuration;
+					std::string protocolType;
 					std::string volumeEncryptionKey;
 					std::string dataDiskSize;
+					int buyDesktopsCount;
 				};
 
 

ecd/include/alibabacloud/ecd/model/DescribeDesktopsInGroupResult.h

@@ -34,6 +34,7 @@ namespace AlibabaCloud
 			public:
 				struct PaidDesktop
 				{
+					std::string fotaVersion;
 					int systemDiskSize;
 					std::string desktopName;
 					std::string desktopId;
@@ -49,6 +50,7 @@ namespace AlibabaCloud
 					std::string endUserId;
 					std::string osType;
 					std::string primaryEniIp;
+					std::string protocolType;
 					std::string imageId;
 					std::string memberEniIp;
 					std::string connectionStatus;
@@ -56,6 +58,7 @@ namespace AlibabaCloud
 				};
 				struct PostPaidDesktop
 				{
+					std::string fotaVersion;
 					int systemDiskSize;
 					std::string createTime;
 					std::string desktopName;
@@ -71,6 +74,7 @@ namespace AlibabaCloud
 					std::string releaseTime;
 					std::string osType;
 					std::string primaryEniIp;
+					std::string protocolType;
 					std::string createDuration;
 					std::string imageId;
 					std::string memberEniIp;

ecd/include/alibabacloud/ecd/model/DescribeDesktopsRequest.h

@@ -36,12 +36,20 @@ public:
 	~DescribeDesktopsRequest();
 	std::string getOfficeSiteId() const;
 	void setOfficeSiteId(const std::string &officeSiteId);
+	std::string getSnapshotPolicyId() const;
+	void setSnapshotPolicyId(const std::string &snapshotPolicyId);
+	std::vector<std::string> getImageId() const;
+	void setImageId(const std::vector<std::string> &imageId);
 	std::string getDesktopStatus() const;
 	void setDesktopStatus(const std::string &desktopStatus);
+	std::string getDesktopGroupId() const;
+	void setDesktopGroupId(const std::string &desktopGroupId);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string getNextToken() const;
 	void setNextToken(const std::string &nextToken);
+	bool getOnlyDesktopGroup() const;
+	void setOnlyDesktopGroup(bool onlyDesktopGroup);
 	bool getQueryFotaUpdate() const;
 	void setQueryFotaUpdate(bool queryFotaUpdate);
 	std::string getDirectoryId() const;
@@ -52,6 +60,8 @@ public:
 	void setDesktopId(const std::vector<std::string> &desktopId);
 	std::vector<Tag> getTag() const;
 	void setTag(const std::vector<Tag> &tag);
+	std::string getDesktopType() const;
+	void setDesktopType(const std::string &desktopType);
 	std::string getDesktopName() const;
 	void setDesktopName(const std::string &desktopName);
 	std::string getGroupId() const;
@@ -68,6 +78,8 @@ public:
 	void setExpiredTime(const std::string &expiredTime);
 	int getMaxResults() const;
 	void setMaxResults(int maxResults);
+	std::vector<std::string> getOsTypes() const;
+	void setOsTypes(const std::vector<std::string> &osTypes);
 	std::string getProtocolType() const;
 	void setProtocolType(const std::string &protocolType);
 	std::string getChargeType() const;
@@ -79,14 +91,19 @@ public:
 
 private:
 	std::string officeSiteId_;
+	std::string snapshotPolicyId_;
+	std::vector<std::string> imageId_;
 	std::string desktopStatus_;
+	std::string desktopGroupId_;
 	std::string regionId_;
 	std::string nextToken_;
+	bool onlyDesktopGroup_;
 	bool queryFotaUpdate_;
 	std::string directoryId_;
 	std::vector<std::string> endUserId_;
 	std::vector<std::string> desktopId_;
 	std::vector<Tag> tag_;
+	std::string desktopType_;
 	std::string desktopName_;
 	std::string groupId_;
 	std::string officeSiteName_;
@@ -95,6 +112,7 @@ private:
 	std::string managementFlag_;
 	std::string expiredTime_;
 	int maxResults_;
+	std::vector<std::string> osTypes_;
 	std::string protocolType_;
 	std::string chargeType_;
 	std::string policyGroupId_;

ecd/include/alibabacloud/ecd/model/DescribeDesktopsResult.h

@@ -59,6 +59,8 @@ namespace AlibabaCloud
 						std::string externalUserName;
 						std::string establishmentTime;
 					};
+					bool supportHibernation;
+					std::string snapshotPolicyId;
 					std::string platform;
 					long memory;
 					std::string desktopName;
@@ -78,17 +80,21 @@ namespace AlibabaCloud
 					std::string bundleName;
 					std::string desktopId;
 					std::vector<std::string> endUserIds;
+					std::vector<std::string> policyGroupIdList;
 					std::string gpuDriverVersion;
 					std::string directoryId;
 					std::string creationTime;
 					std::vector<Desktop::Disk> disks;
+					std::string snapshotPolicyName;
 					std::string dataDiskSize;
 					std::string managementFlag;
 					long downgradedTimes;
 					std::string sessionType;
 					int systemDiskSize;
+					int bindAmount;
 					bool volumeEncryptionEnabled;
 					std::string networkInterfaceId;
+					bool hibernationOptionsConfigured;
 					std::string zoneType;
 					std::string networkInterfaceIp;
 					std::string officeSiteName;
@@ -96,6 +102,7 @@ namespace AlibabaCloud
 					std::string dataDiskCategory;
 					std::string officeSiteVpcType;
 					std::string progress;
+					std::vector<std::string> policyGroupNameList;
 					std::string policyGroupId;
 					std::string policyGroupName;
 					std::vector<std::string> managementFlags;

ecd/include/alibabacloud/ecd/model/DescribeDevicesRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECD_MODEL_DESCRIBEDEVICESREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_DESCRIBEDEVICESREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT DescribeDevicesRequest : public RpcServiceRequest {
+public:
+	DescribeDevicesRequest();
+	~DescribeDevicesRequest();
+	std::string getClientType() const;
+	void setClientType(const std::string &clientType);
+	std::string getUserType() const;
+	void setUserType(const std::string &userType);
+	std::string getDeviceId() const;
+	void setDeviceId(const std::string &deviceId);
+	int getPageNumber() const;
+	void setPageNumber(int pageNumber);
+	std::string getAdDomain() const;
+	void setAdDomain(const std::string &adDomain);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	std::string getDirectoryId() const;
+	void setDirectoryId(const std::string &directoryId);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+
+private:
+	std::string clientType_;
+	std::string userType_;
+	std::string deviceId_;
+	int pageNumber_;
+	std::string adDomain_;
+	int pageSize_;
+	std::string endUserId_;
+	std::string directoryId_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_DESCRIBEDEVICESREQUEST_H_

ecd/include/alibabacloud/ecd/model/DescribeDevicesResult.h

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

ecd/include/alibabacloud/ecd/model/DescribeFotaTasksResult.h

@@ -38,6 +38,7 @@ namespace AlibabaCloud
 					std::string status;
 					std::string taskUid;
 					int pendingDesktopCount;
+					int pendingCustomImageCount;
 					int size;
 					std::string releaseNote;
 					std::string publishTime;

ecd/include/alibabacloud/ecd/model/DescribeImagesRequest.h

@@ -46,6 +46,8 @@ public:
 	void setFotaChannel(const std::string &fotaChannel);
 	std::string getImageType() const;
 	void setImageType(const std::string &imageType);
+	std::string getSessionType() const;
+	void setSessionType(const std::string &sessionType);
 	std::string getOsType() const;
 	void setOsType(const std::string &osType);
 	std::string getImageStatus() const;
@@ -66,6 +68,7 @@ private:
 	std::string nextToken_;
 	std::string fotaChannel_;
 	std::string imageType_;
+	std::string sessionType_;
 	std::string osType_;
 	std::string imageStatus_;
 	int maxResults_;

ecd/include/alibabacloud/ecd/model/DescribeImagesResult.h

@@ -39,6 +39,7 @@ namespace AlibabaCloud
 					std::string sessionType;
 					std::string description;
 					int sharedCount;
+					std::string platform;
 					int size;
 					bool volumeEncryptionEnabled;
 					std::string imageType;
@@ -52,6 +53,7 @@ namespace AlibabaCloud
 					std::string creationTime;
 					std::string imageId;
 					bool gpuCategory;
+					std::string updateTime;
 					int dataDiskSize;
 				};
 

ecd/include/alibabacloud/ecd/model/DescribeInvocationsRequest.h

@@ -32,6 +32,8 @@ public:
 	~DescribeInvocationsRequest();
 	std::string getInvokeStatus() const;
 	void setInvokeStatus(const std::string &invokeStatus);
+	std::vector<std::string> getDesktopIds() const;
+	void setDesktopIds(const std::vector<std::string> &desktopIds);
 	bool getIncludeOutput() const;
 	void setIncludeOutput(bool includeOutput);
 	std::string getRegionId() const;
@@ -53,6 +55,7 @@ public:
 
 private:
 	std::string invokeStatus_;
+	std::vector<std::string> desktopIds_;
 	bool includeOutput_;
 	std::string regionId_;
 	std::string nextToken_;

ecd/include/alibabacloud/ecd/model/DescribeNASFileSystemsRequest.h

@@ -32,6 +32,8 @@ public:
 	~DescribeNASFileSystemsRequest();
 	std::string getOfficeSiteId() const;
 	void setOfficeSiteId(const std::string &officeSiteId);
+	bool getMatchCompatibleProfile() const;
+	void setMatchCompatibleProfile(bool matchCompatibleProfile);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string getNextToken() const;
@@ -43,6 +45,7 @@ public:
 
 private:
 	std::string officeSiteId_;
+	bool matchCompatibleProfile_;
 	std::string regionId_;
 	std::string nextToken_;
 	int maxResults_;

ecd/include/alibabacloud/ecd/model/DescribeNASFileSystemsResult.h

@@ -34,15 +34,23 @@ namespace AlibabaCloud
 			public:
 				struct FileSystem
 				{
+					struct DesktopGroup
+					{
+						std::string desktopGroupId;
+						std::string desktopGroupName;
+					};
 					bool supportAcl;
 					std::string storageType;
 					std::string description;
+					std::vector<FileSystem::DesktopGroup> desktopGroups;
 					std::string zoneId;
 					std::string createTime;
 					std::string mountTargetStatus;
 					long meteredSize;
 					bool encryptionEnabled;
 					std::string officeSiteId;
+					bool profileCompatible;
+					std::string domainId;
 					long capacity;
 					std::string mountTargetDomain;
 					std::string fileSystemType;

ecd/include/alibabacloud/ecd/model/DescribeNetworkPackagesResult.h

@@ -34,17 +34,22 @@ namespace AlibabaCloud
 			public:
 				struct NetworkPackage
 				{
+					std::string networkPackageId;
+					std::string createTime;
+					std::string payType;
+					std::string internetChargeType;
+					std::string reservationInternetChargeType;
 					std::string qosType;
 					std::string officeSiteId;
 					std::vector<std::string> eipAddresses;
 					std::string vpcSnatPolicy;
-					std::string networkPackageId;
 					int bandwidth;
 					std::string expiredTime;
-					std::string createTime;
+					std::string ngwVersion;
 					std::string officeSiteName;
+					std::string reservationActiveTime;
+					int reservationBandwidth;
 					std::string networkPackageStatus;
-					std::string internetChargeType;
 					std::string officeSiteVpcType;
 				};
 

ecd/include/alibabacloud/ecd/model/DescribeOfficeSitesRequest.h

@@ -36,6 +36,8 @@ public:
 	void setVpcType(const std::string &vpcType);
 	bool getEnableInternetAccess() const;
 	void setEnableInternetAccess(bool enableInternetAccess);
+	bool getVpcNotNone() const;
+	void setVpcNotNone(bool vpcNotNone);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string getOfficeSiteType() const;
@@ -51,6 +53,7 @@ private:
 	std::vector<std::string> officeSiteId_;
 	std::string vpcType_;
 	bool enableInternetAccess_;
+	bool vpcNotNone_;
 	std::string regionId_;
 	std::string officeSiteType_;
 	std::string nextToken_;

ecd/include/alibabacloud/ecd/model/DescribeOfficeSitesResult.h

@@ -66,10 +66,13 @@ namespace AlibabaCloud
 					int bandwidth;
 					bool enableInternetAccess;
 					std::string dnsUserName;
+					std::string rdsLicenseAddress;
 					std::string status;
 					std::string domainName;
 					std::vector<std::string> vSwitchIds;
 					bool needVerifyLoginRisk;
+					std::string rdsLicenseStatus;
+					std::string rdsLicenseDomainName;
 					bool enableAdminAccess;
 					std::string officeSiteType;
 					std::vector<std::string> fileSystemIds;

ecd/include/alibabacloud/ecd/model/DescribePolicyGroupsRequest.h

@@ -34,6 +34,8 @@ public:
 	void setRegionId(const std::string &regionId);
 	std::string getNextToken() const;
 	void setNextToken(const std::string &nextToken);
+	std::string getScope() const;
+	void setScope(const std::string &scope);
 	int getMaxResults() const;
 	void setMaxResults(int maxResults);
 	std::vector<std::string> getPolicyGroupId() const;
@@ -42,6 +44,7 @@ public:
 private:
 	std::string regionId_;
 	std::string nextToken_;
+	std::string scope_;
 	int maxResults_;
 	std::vector<std::string> policyGroupId_;
 };

ecd/include/alibabacloud/ecd/model/DescribePolicyGroupsResult.h

@@ -64,40 +64,81 @@ namespace AlibabaCloud
 						long usbRedirectType;
 						std::string productId;
 					};
+					struct DomainResolveRuleItem
+					{
+						std::string policy;
+						std::string description;
+						std::string domain;
+					};
+					struct NetRedirectRuleItem
+					{
+						std::string policy;
+						std::string ruleType;
+						std::string domain;
+					};
 					std::string watermarkType;
 					std::string watermarkTransparency;
 					std::string cameraRedirect;
 					std::string domainList;
+					std::string domainResolveRuleType;
 					long recordingFps;
-					std::string appContentProtection;
 					std::string gpuAcceleration;
 					std::string recordingStartTime;
 					std::string name;
 					std::string remoteCoordinate;
-					std::string usbRedirect;
+					int watermarkTransparencyValue;
+					int watermarkColor;
 					std::string watermarkCustomText;
 					int edsCount;
-					std::string visualQuality;
+					std::string memoryProtectedMode;
-					std::vector<DescribePolicyGroup::UsbSupplyRedirectRuleItem> usbSupplyRedirectRule;
+					std::vector<DescribePolicyGroup::NetRedirectRuleItem> netRedirectRule;
-					std::string policyGroupId;
+					std::string videoRedirect;
-					std::string recordingEndTime;
+					std::string cpuProtectedMode;
 					std::string printerRedirection;
+					int memorySingleRateLimit;
+					std::vector<DescribePolicyGroup::DomainResolveRuleItem> domainResolveRule;
+					int memoryRateLimit;
 					std::string policyGroupType;
 					std::vector<DescribePolicyGroup::AuthorizeAccessPolicyRule> authorizeAccessPolicyRules;
-					std::string localDrive;
-					std::vector<std::string> preemptLoginUsers;
 					std::string policyStatus;
+					int memoryDownGradeDuration;
 					std::vector<DescribePolicyGroup::ClientType> clientTypes;
 					std::string netRedirect;
-					std::vector<DescribePolicyGroup::AuthorizeSecurityPolicyRule> authorizeSecurityPolicyRules;
 					std::string preemptLogin;
+					std::string endUserGroupCoordinate;
+					std::string html5Access;
+					long recordingExpires;
+					std::string watermarkFontStyle;
+					int recordingDuration;
+					int cpuDownGradeDuration;
+					std::string appContentProtection;
+					std::vector<std::string> cpuProcessors;
+					int watermarkFontSize;
+					double watermarkDegree;
+					std::string usbRedirect;
+					std::string endUserApplyAdminCoordinate;
+					std::string recordingAudio;
+					int watermarkRowAmount;
+					std::string visualQuality;
+					std::string internetCommunicationProtocol;
+					std::vector<DescribePolicyGroup::UsbSupplyRedirectRuleItem> usbSupplyRedirectRule;
+					int cpuSampleDuration;
+					int cpuSingleRateLimit;
+					std::string policyGroupId;
+					std::string recordingEndTime;
+					int memorySampleDuration;
+					std::string scope;
+					int cpuRateLimit;
+					std::string localDrive;
+					std::vector<std::string> preemptLoginUsers;
+					std::vector<DescribePolicyGroup::AuthorizeSecurityPolicyRule> authorizeSecurityPolicyRules;
 					long recordContentExpires;
 					std::string html5FileTransfer;
 					std::string clipboard;
 					std::string recording;
-					std::string html5Access;
+					std::vector<std::string> scopeValue;
-					long recordingExpires;
 					std::string watermark;
+					std::vector<std::string> memoryProcessors;
 					std::string recordContent;
 				};
 

ecd/include/alibabacloud/ecd/model/DescribeSnapshotsRequest.h

@@ -32,21 +32,42 @@ public:
 	~DescribeSnapshotsRequest();
 	std::string getSnapshotId() const;
 	void setSnapshotId(const std::string &snapshotId);
+	std::string getSnapshotName() const;
+	void setSnapshotName(const std::string &snapshotName);
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::string getNextToken() const;
 	void setNextToken(const std::string &nextToken);
-	int getMaxResults() const;
-	void setMaxResults(int maxResults);
 	std::string getDesktopId() const;
 	void setDesktopId(const std::string &desktopId);
+	std::string getDesktopName() const;
+	void setDesktopName(const std::string &desktopName);
+	std::string getCreator() const;
+	void setCreator(const std::string &creator);
+	std::string getSourceDiskType() const;
+	void setSourceDiskType(const std::string &sourceDiskType);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	std::string getSnapshotType() const;
+	void setSnapshotType(const std::string &snapshotType);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
 
 private:
 	std::string snapshotId_;
+	std::string snapshotName_;
+	std::string startTime_;
 	std::string regionId_;
 	std::string nextToken_;
-	int maxResults_;
 	std::string desktopId_;
+	std::string desktopName_;
+	std::string creator_;
+	std::string sourceDiskType_;
+	std::string endTime_;
+	std::string snapshotType_;
+	int maxResults_;
 };
 } // namespace Model
 } // namespace Ecd

ecd/include/alibabacloud/ecd/model/DescribeSnapshotsResult.h

@@ -37,9 +37,13 @@ namespace AlibabaCloud
 					std::string status;
 					std::string progress;
 					std::string description;
+					std::string desktopName;
+					std::string deletionTime;
 					std::string desktopId;
 					bool volumeEncryptionEnabled;
+					std::string creator;
 					std::string snapshotName;
+					std::string desktopStatus;
 					std::string snapshotId;
 					std::string sourceDiskSize;
 					std::string protocolType;

ecd/include/alibabacloud/ecd/model/DescribeSuspEventsResult.h

@@ -57,6 +57,7 @@ namespace AlibabaCloud
 					std::string desc;
 					std::string operateMsg;
 					std::string canBeDealOnLine;
+					std::string desktopGroupId;
 					std::vector<SuspEvent::Detail> details;
 					std::string alarmEventType;
 					std::string alarmUniqueInfo;

ecd/include/alibabacloud/ecd/model/DescribeUserProfilePathRulesRequest.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_ECD_MODEL_DESCRIBEUSERPROFILEPATHRULESREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_DESCRIBEUSERPROFILEPATHRULESREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT DescribeUserProfilePathRulesRequest : public RpcServiceRequest {
+public:
+	DescribeUserProfilePathRulesRequest();
+	~DescribeUserProfilePathRulesRequest();
+	std::string getRuleType() const;
+	void setRuleType(const std::string &ruleType);
+	std::string getDesktopGroupId() const;
+	void setDesktopGroupId(const std::string &desktopGroupId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	std::string ruleType_;
+	std::string desktopGroupId_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_DESCRIBEUSERPROFILEPATHRULESREQUEST_H_

ecd/include/alibabacloud/ecd/model/DescribeUserProfilePathRulesResult.h

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

ecd/include/alibabacloud/ecd/model/DescribeUsersInGroupRequest.h

@@ -30,6 +30,8 @@ class ALIBABACLOUD_ECD_EXPORT DescribeUsersInGroupRequest : public RpcServiceReq
 public:
 	DescribeUsersInGroupRequest();
 	~DescribeUsersInGroupRequest();
+	std::vector<std::string> getEndUserIds() const;
+	void setEndUserIds(const std::vector<std::string> &endUserIds);
 	int getConnectState() const;
 	void setConnectState(int connectState);
 	std::string getOrgId() const;
@@ -50,6 +52,7 @@ public:
 	void setEndUserId(const std::string &endUserId);
 
 private:
+	std::vector<std::string> endUserIds_;
 	int connectState_;
 	std::string orgId_;
 	std::string filter_;

ecd/include/alibabacloud/ecd/model/DetachEndUserRequest.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_ECD_MODEL_DETACHENDUSERREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_DETACHENDUSERREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT DetachEndUserRequest : public RpcServiceRequest {
+public:
+	DetachEndUserRequest();
+	~DetachEndUserRequest();
+	std::string getClientType() const;
+	void setClientType(const std::string &clientType);
+	std::string getDeviceId() const;
+	void setDeviceId(const std::string &deviceId);
+	std::string getAdDomain() const;
+	void setAdDomain(const std::string &adDomain);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	std::string getDirectoryId() const;
+	void setDirectoryId(const std::string &directoryId);
+	std::string getRegion() const;
+	void setRegion(const std::string &region);
+
+private:
+	std::string clientType_;
+	std::string deviceId_;
+	std::string adDomain_;
+	std::string endUserId_;
+	std::string directoryId_;
+	std::string region_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_DETACHENDUSERREQUEST_H_

ecd/include/alibabacloud/ecd/model/DetachEndUserResult.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_ECD_MODEL_DETACHENDUSERRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_DETACHENDUSERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT DetachEndUserResult : public ServiceResult
+			{
+			public:
+
+
+				DetachEndUserResult();
+				explicit DetachEndUserResult(const std::string &payload);
+				~DetachEndUserResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_DETACHENDUSERRESULT_H_

ecd/include/alibabacloud/ecd/model/ExportClientEventsRequest.h

@@ -52,6 +52,8 @@ public:
 	void setMaxResults(int maxResults);
 	std::string getEventType() const;
 	void setEventType(const std::string &eventType);
+	std::string getLangType() const;
+	void setLangType(const std::string &langType);
 
 private:
 	std::string officeSiteId_;
@@ -65,6 +67,7 @@ private:
 	std::string officeSiteName_;
 	int maxResults_;
 	std::string eventType_;
+	std::string langType_;
 };
 } // namespace Model
 } // namespace Ecd

ecd/include/alibabacloud/ecd/model/GetConnectionTicketRequest.h

@@ -34,6 +34,8 @@ public:
 	void setResourceOwnerId(long resourceOwnerId);
 	std::string getUuid() const;
 	void setUuid(const std::string &uuid);
+	std::string getCommandContent() const;
+	void setCommandContent(const std::string &commandContent);
 	std::string getPassword() const;
 	void setPassword(const std::string &password);
 	std::string getRegionId() const;
@@ -52,6 +54,7 @@ public:
 private:
 	long resourceOwnerId_;
 	std::string uuid_;
+	std::string commandContent_;
 	std::string password_;
 	std::string regionId_;
 	std::string endUserId_;

ecd/include/alibabacloud/ecd/model/GetDesktopGroupDetailResult.h

@@ -41,50 +41,67 @@ namespace AlibabaCloud
 						std::string cronExpression;
 						bool forced;
 					};
-					std::vector<TimerInfo> timerInfos;
+					struct ScaleTimerInfo
-					int systemDiskSize;
+					{
-					int bindAmount;
+						std::string type;
+						int buyResAmount;
+						int loadPolicy;
+						int maxResAmount;
+						long keepDuration;
+						float ratioThreshold;
+						std::string cron;
+						int minResAmount;
+					};
 					long connectDuration;
 					long memory;
 					std::string desktopGroupName;
 					int cpu;
 					std::string creator;
 					std::string ownBundleId;
-					int resType;
+					std::vector<std::string> policyGroupIds;
 					std::string directoryType;
-					std::string nasFileSystemName;
 					int allowBufferCount;
 					int ownType;
-					int loadPolicy;
 					long version;
 					long keepDuration;
 					std::string expiredTime;
+					std::string imageId;
+					int resetType;
+					int minDesktopsCount;
+					std::string ownBundleName;
+					int status;
+					std::string officeSiteType;
+					std::string payType;
+					bool profileFollowSwitch;
+					std::string directoryId;
+					std::string creationTime;
+					std::string timingStrategyInfo;
+					std::string dataDiskSize;
+					int buyDesktopsCount;
+					std::vector<TimerInfo> timerInfos;
+					int systemDiskSize;
+					int bindAmount;
+					int resType;
+					std::vector<ScaleTimerInfo> scaleTimerInfos;
+					std::string nasFileSystemName;
+					int loadPolicy;
 					int maxDesktopsCount;
 					long idleDisconnectDuration;
 					std::string officeSiteName;
-					int resetType;
 					float gpuCount;
-					int minDesktopsCount;
 					std::string dataDiskCategory;
-					std::string ownBundleName;
-					int status;
 					std::string policyGroupId;
 					std::string comments;
-					std::string officeSiteType;
+					std::vector<std::string> policyGroupNames;
 					float ratioThreshold;
 					std::string policyGroupName;
-					std::string payType;
 					std::string systemDiskCategory;
 					std::string officeSiteId;
 					std::string desktopGroupId;
-					bool profileFollowSwitch;
-					std::string directoryId;
 					std::string gpuSpec;
 					long stopDuration;
-					std::string creationTime;
 					int allowAutoSetup;
 					std::string nasFileSystemID;
-					std::string dataDiskSize;
 				};
 
 

ecd/include/alibabacloud/ecd/model/HibernateDesktopsRequest.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_ECD_MODEL_HIBERNATEDESKTOPSREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_HIBERNATEDESKTOPSREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT HibernateDesktopsRequest : public RpcServiceRequest {
+public:
+	HibernateDesktopsRequest();
+	~HibernateDesktopsRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getDesktopId() const;
+	void setDesktopId(const std::vector<std::string> &desktopId);
+
+private:
+	std::string regionId_;
+	std::vector<std::string> desktopId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_HIBERNATEDESKTOPSREQUEST_H_

ecd/include/alibabacloud/ecd/model/HibernateDesktopsResult.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_ECD_MODEL_HIBERNATEDESKTOPSRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_HIBERNATEDESKTOPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT HibernateDesktopsResult : public ServiceResult
+			{
+			public:
+
+
+				HibernateDesktopsResult();
+				explicit HibernateDesktopsResult(const std::string &payload);
+				~HibernateDesktopsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_HIBERNATEDESKTOPSRESULT_H_

ecd/include/alibabacloud/ecd/model/ListCdsFilesRequest.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_ECD_MODEL_LISTCDSFILESREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_LISTCDSFILESREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT ListCdsFilesRequest : public RpcServiceRequest {
+public:
+	ListCdsFilesRequest();
+	~ListCdsFilesRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	std::string getRootId() const;
+	void setRootId(const std::string &rootId);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getParentFileId() const;
+	void setParentFileId(const std::string &parentFileId);
+	std::string getFileIds() const;
+	void setFileIds(const std::string &fileIds);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+	std::string getOrderType() const;
+	void setOrderType(const std::string &orderType);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	std::string regionId_;
+	std::string nextToken_;
+	std::string endUserId_;
+	std::string rootId_;
+	std::string cdsId_;
+	std::string parentFileId_;
+	std::string fileIds_;
+	int maxResults_;
+	std::string orderType_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_LISTCDSFILESREQUEST_H_

ecd/include/alibabacloud/ecd/model/ListCdsFilesResult.h

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECD_MODEL_LISTCDSFILESRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_LISTCDSFILESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT ListCdsFilesResult : public ServiceResult
+			{
+			public:
+				struct FileModel
+				{
+					std::string rootId;
+					std::string sha1;
+					std::string description;
+					std::string category;
+					std::string contentType;
+					long openTimeStamp;
+					long size;
+					std::string driveId;
+					std::string creator;
+					std::string thumbnail;
+					std::string name;
+					std::string openTime;
+					std::string modifiedTime;
+					std::string fileExtension;
+					std::string modifier;
+					std::string downloadUrl;
+					std::string md5;
+					std::string status;
+					std::string parentId;
+					std::string filePath;
+					std::string storageType;
+					std::string createTime;
+					std::string domainId;
+					std::string fileType;
+					std::string fileId;
+					std::string regionId;
+				};
+
+
+				ListCdsFilesResult();
+				explicit ListCdsFilesResult(const std::string &payload);
+				~ListCdsFilesResult();
+				std::string getNextToken()const;
+				std::string getMessage()const;
+				std::string getCount()const;
+				std::vector<FileModel> getFileModels()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string nextToken_;
+				std::string message_;
+				std::string count_;
+				std::vector<FileModel> fileModels_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_LISTCDSFILESRESULT_H_

ecd/include/alibabacloud/ecd/model/ListFilePermissionRequest.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_ECD_MODEL_LISTFILEPERMISSIONREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_LISTFILEPERMISSIONREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT ListFilePermissionRequest : public RpcServiceRequest {
+public:
+	ListFilePermissionRequest();
+	~ListFilePermissionRequest();
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	std::string getFileId() const;
+	void setFileId(const std::string &fileId);
+
+private:
+	std::string cdsId_;
+	std::string regionId_;
+	std::string endUserId_;
+	std::string fileId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_LISTFILEPERMISSIONREQUEST_H_

ecd/include/alibabacloud/ecd/model/ListFilePermissionResult.h

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

ecd/include/alibabacloud/ecd/model/ListUserAdOrganizationUnitsRequest.h

@@ -32,12 +32,21 @@ public:
 	~ListUserAdOrganizationUnitsRequest();
 	std::string getOfficeSiteId() const;
 	void setOfficeSiteId(const std::string &officeSiteId);
+	std::string getFilter() const;
+	void setFilter(const std::string &filter);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
 
 private:
 	std::string officeSiteId_;
+	std::string filter_;
 	std::string regionId_;
+	std::string nextToken_;
+	int maxResults_;
 };
 } // namespace Model
 } // namespace Ecd

ecd/include/alibabacloud/ecd/model/ListUserAdOrganizationUnitsResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					std::string oUName;
 					std::string officeSiteId;
+					std::string displayOUName;
 				};
 
 
@@ -43,11 +44,13 @@ namespace AlibabaCloud
 				explicit ListUserAdOrganizationUnitsResult(const std::string &payload);
 				~ListUserAdOrganizationUnitsResult();
 				std::vector<OuName> getOUNames()const;
+				std::string getNextToken()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::vector<OuName> oUNames_;
+				std::string nextToken_;
 
 			};
 		}

ecd/include/alibabacloud/ecd/model/MigrateDesktopsRequest.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_ECD_MODEL_MIGRATEDESKTOPSREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_MIGRATEDESKTOPSREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT MigrateDesktopsRequest : public RpcServiceRequest {
+public:
+	MigrateDesktopsRequest();
+	~MigrateDesktopsRequest();
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getDesktopId() const;
+	void setDesktopId(const std::vector<std::string> &desktopId);
+	std::string getTargetOfficeSiteId() const;
+	void setTargetOfficeSiteId(const std::string &targetOfficeSiteId);
+
+private:
+	std::string regionId_;
+	std::vector<std::string> desktopId_;
+	std::string targetOfficeSiteId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_MIGRATEDESKTOPSREQUEST_H_

ecd/include/alibabacloud/ecd/model/MigrateDesktopsResult.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_ECD_MODEL_MIGRATEDESKTOPSRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_MIGRATEDESKTOPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT MigrateDesktopsResult : public ServiceResult
+			{
+			public:
+
+
+				MigrateDesktopsResult();
+				explicit MigrateDesktopsResult(const std::string &payload);
+				~MigrateDesktopsResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_MIGRATEDESKTOPSRESULT_H_

ecd/include/alibabacloud/ecd/model/ModifyAutoSnapshotPolicyRequest.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_ECD_MODEL_MODIFYAUTOSNAPSHOTPOLICYREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_MODIFYAUTOSNAPSHOTPOLICYREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT ModifyAutoSnapshotPolicyRequest : public RpcServiceRequest {
+public:
+	ModifyAutoSnapshotPolicyRequest();
+	~ModifyAutoSnapshotPolicyRequest();
+	std::string getCronExpression() const;
+	void setCronExpression(const std::string &cronExpression);
+	std::string getPolicyId() const;
+	void setPolicyId(const std::string &policyId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getPolicyName() const;
+	void setPolicyName(const std::string &policyName);
+	int getRetentionDays() const;
+	void setRetentionDays(int retentionDays);
+
+private:
+	std::string cronExpression_;
+	std::string policyId_;
+	std::string regionId_;
+	std::string policyName_;
+	int retentionDays_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_MODIFYAUTOSNAPSHOTPOLICYREQUEST_H_

ecd/include/alibabacloud/ecd/model/ModifyAutoSnapshotPolicyResult.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_ECD_MODEL_MODIFYAUTOSNAPSHOTPOLICYRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_MODIFYAUTOSNAPSHOTPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT ModifyAutoSnapshotPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyAutoSnapshotPolicyResult();
+				explicit ModifyAutoSnapshotPolicyResult(const std::string &payload);
+				~ModifyAutoSnapshotPolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_MODIFYAUTOSNAPSHOTPOLICYRESULT_H_

ecd/include/alibabacloud/ecd/model/ModifyCdsFileRequest.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_ECD_MODEL_MODIFYCDSFILEREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_MODIFYCDSFILEREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT ModifyCdsFileRequest : public RpcServiceRequest {
+public:
+	ModifyCdsFileRequest();
+	~ModifyCdsFileRequest();
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getConflictPolicy() const;
+	void setConflictPolicy(const std::string &conflictPolicy);
+	std::string getFileName() const;
+	void setFileName(const std::string &fileName);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getEndUserId() const;
+	void setEndUserId(const std::string &endUserId);
+	std::string getFileId() const;
+	void setFileId(const std::string &fileId);
+
+private:
+	std::string cdsId_;
+	std::string conflictPolicy_;
+	std::string fileName_;
+	std::string regionId_;
+	std::string endUserId_;
+	std::string fileId_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_MODIFYCDSFILEREQUEST_H_

ecd/include/alibabacloud/ecd/model/ModifyCdsFileResult.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_ECD_MODEL_MODIFYCDSFILERESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_MODIFYCDSFILERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT ModifyCdsFileResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyCdsFileResult();
+				explicit ModifyCdsFileResult(const std::string &payload);
+				~ModifyCdsFileResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_MODIFYCDSFILERESULT_H_

ecd/include/alibabacloud/ecd/model/ModifyCdsFileShareLinkRequest.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_ECD_MODEL_MODIFYCDSFILESHARELINKREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_MODIFYCDSFILESHARELINKREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT ModifyCdsFileShareLinkRequest : public RpcServiceRequest {
+public:
+	ModifyCdsFileShareLinkRequest();
+	~ModifyCdsFileShareLinkRequest();
+	std::string getDescription() const;
+	void setDescription(const std::string &description);
+	std::string getShareId() const;
+	void setShareId(const std::string &shareId);
+	long getPreviewLimit() const;
+	void setPreviewLimit(long previewLimit);
+	bool getDisableDownload() const;
+	void setDisableDownload(bool disableDownload);
+	bool getDisablePreview() const;
+	void setDisablePreview(bool disablePreview);
+	std::string getSharePwd() const;
+	void setSharePwd(const std::string &sharePwd);
+	std::string getShareName() const;
+	void setShareName(const std::string &shareName);
+	long getDownloadCount() const;
+	void setDownloadCount(long downloadCount);
+	bool getDisableSave() const;
+	void setDisableSave(bool disableSave);
+	long getSaveCount() const;
+	void setSaveCount(long saveCount);
+	long getReportCount() const;
+	void setReportCount(long reportCount);
+	long getVideoPreviewCount() const;
+	void setVideoPreviewCount(long videoPreviewCount);
+	long getDownloadLimit() const;
+	void setDownloadLimit(long downloadLimit);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	long getSaveLimit() const;
+	void setSaveLimit(long saveLimit);
+	std::string getExpiration() const;
+	void setExpiration(const std::string &expiration);
+	long getPreviewCount() const;
+	void setPreviewCount(long previewCount);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	std::string description_;
+	std::string shareId_;
+	long previewLimit_;
+	bool disableDownload_;
+	bool disablePreview_;
+	std::string sharePwd_;
+	std::string shareName_;
+	long downloadCount_;
+	bool disableSave_;
+	long saveCount_;
+	long reportCount_;
+	long videoPreviewCount_;
+	long downloadLimit_;
+	std::string cdsId_;
+	long saveLimit_;
+	std::string expiration_;
+	long previewCount_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_MODIFYCDSFILESHARELINKREQUEST_H_

ecd/include/alibabacloud/ecd/model/ModifyCdsFileShareLinkResult.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_ECD_MODEL_MODIFYCDSFILESHARELINKRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_MODIFYCDSFILESHARELINKRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT ModifyCdsFileShareLinkResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					long previewCount;
+					std::string description;
+					long saveLimit;
+					long downloadLimit;
+					std::string shareName;
+					std::string driveId;
+					std::string creator;
+					bool disablePreview;
+					long videoPreviewCount;
+					std::string shareId;
+					bool disableDownload;
+					std::string status;
+					std::string createTime;
+					std::string expiration;
+					bool expired;
+					long saveCount;
+					std::string modifiyTime;
+					long reportCount;
+					long previewLimit;
+					bool disableSave;
+					std::string sharePwd;
+					std::string shareLink;
+					std::string fileIds;
+					long downloadCount;
+					long accessCount;
+				};
+
+
+				ModifyCdsFileShareLinkResult();
+				explicit ModifyCdsFileShareLinkResult(const std::string &payload);
+				~ModifyCdsFileShareLinkResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_MODIFYCDSFILESHARELINKRESULT_H_

ecd/include/alibabacloud/ecd/model/ModifyCloudDriveGroupsRequest.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_ECD_MODEL_MODIFYCLOUDDRIVEGROUPSREQUEST_H_
+#define ALIBABACLOUD_ECD_MODEL_MODIFYCLOUDDRIVEGROUPSREQUEST_H_
+
+#include <alibabacloud/ecd/EcdExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Ecd {
+namespace Model {
+class ALIBABACLOUD_ECD_EXPORT ModifyCloudDriveGroupsRequest : public RpcServiceRequest {
+public:
+	ModifyCloudDriveGroupsRequest();
+	~ModifyCloudDriveGroupsRequest();
+	long getTotalSize() const;
+	void setTotalSize(long totalSize);
+	std::vector<std::string> getGroupId() const;
+	void setGroupId(const std::vector<std::string> &groupId);
+	std::string getCdsId() const;
+	void setCdsId(const std::string &cdsId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getStatus() const;
+	void setStatus(const std::string &status);
+
+private:
+	long totalSize_;
+	std::vector<std::string> groupId_;
+	std::string cdsId_;
+	std::string regionId_;
+	std::string status_;
+};
+} // namespace Model
+} // namespace Ecd
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_ECD_MODEL_MODIFYCLOUDDRIVEGROUPSREQUEST_H_

ecd/include/alibabacloud/ecd/model/ModifyCloudDriveGroupsResult.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_ECD_MODEL_MODIFYCLOUDDRIVEGROUPSRESULT_H_
+#define ALIBABACLOUD_ECD_MODEL_MODIFYCLOUDDRIVEGROUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ecd/EcdExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Ecd
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ECD_EXPORT ModifyCloudDriveGroupsResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyCloudDriveGroupsResult();
+				explicit ModifyCloudDriveGroupsResult(const std::string &payload);
+				~ModifyCloudDriveGroupsResult();
+				std::string getMessage()const;
+				std::string getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ECD_MODEL_MODIFYCLOUDDRIVEGROUPSRESULT_H_

ecd/include/alibabacloud/ecd/model/ModifyDesktopGroupRequest.h

@@ -46,6 +46,8 @@ public:
 	void setDesktopGroupName(const std::string &desktopGroupName);
 	int getAllowBufferCount() const;
 	void setAllowBufferCount(int allowBufferCount);
+	std::vector<std::string> getPolicyGroupIds() const;
+	void setPolicyGroupIds(const std::vector<std::string> &policyGroupIds);
 	long getIdleDisconnectDuration() const;
 	void setIdleDisconnectDuration(long idleDisconnectDuration);
 	std::string getDesktopGroupId() const;
@@ -76,6 +78,8 @@ public:
 	void setConnectDuration(long connectDuration);
 	bool getProfileFollowSwitch() const;
 	void setProfileFollowSwitch(bool profileFollowSwitch);
+	int getBuyDesktopsCount() const;
+	void setBuyDesktopsCount(int buyDesktopsCount);
 	std::string getPolicyGroupId() const;
 	void setPolicyGroupId(const std::string &policyGroupId);
 
@@ -88,6 +92,7 @@ private:
 	long loadPolicy_;
 	std::string desktopGroupName_;
 	int allowBufferCount_;
+	std::vector<std::string> policyGroupIds_;
 	long idleDisconnectDuration_;
 	std::string desktopGroupId_;
 	std::string regionId_;
@@ -103,6 +108,7 @@ private:
 	long keepDuration_;
 	long connectDuration_;
 	bool profileFollowSwitch_;
+	int buyDesktopsCount_;
 	std::string policyGroupId_;
 };
 } // namespace Model

ecd/include/alibabacloud/ecd/model/ModifyDesktopsPolicyGroupRequest.h

@@ -30,6 +30,10 @@ class ALIBABACLOUD_ECD_EXPORT ModifyDesktopsPolicyGroupRequest : public RpcServi
 public:
 	ModifyDesktopsPolicyGroupRequest();
 	~ModifyDesktopsPolicyGroupRequest();
+	bool getPreCheck() const;
+	void setPreCheck(bool preCheck);
+	std::vector<std::string> getPolicyGroupIds() const;
+	void setPolicyGroupIds(const std::vector<std::string> &policyGroupIds);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
 	std::vector<std::string> getDesktopId() const;
@@ -38,6 +42,8 @@ public:
 	void setPolicyGroupId(const std::string &policyGroupId);
 
 private:
+	bool preCheck_;
+	std::vector<std::string> policyGroupIds_;
 	std::string regionId_;
 	std::vector<std::string> desktopId_;
 	std::string policyGroupId_;

ecd/include/alibabacloud/ecd/model/ModifyDesktopsPolicyGroupResult.h

@@ -35,6 +35,7 @@ namespace AlibabaCloud
 				struct ModifyResult
 				{
 					std::string message;
+					bool checkResult;
 					std::string desktopId;
 					std::string code;
 				};

ecd/include/alibabacloud/ecd/model/ModifyOfficeSiteAttributeRequest.h

@@ -42,6 +42,8 @@ public:
 	void setNeedVerifyZeroDevice(bool needVerifyZeroDevice);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
+	bool getEnableAdminAccess() const;
+	void setEnableAdminAccess(bool enableAdminAccess);
 
 private:
 	std::string officeSiteId_;
@@ -50,6 +52,7 @@ private:
 	bool needVerifyLoginRisk_;
 	bool needVerifyZeroDevice_;
 	std::string regionId_;
+	bool enableAdminAccess_;
 };
 } // namespace Model
 } // namespace Ecd