|
|
@@ -0,0 +1,1278 @@
|
|
|
+/*
|
|
|
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
|
|
|
+ *
|
|
|
+ * Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
+ * you may not use this file except in compliance with the License.
|
|
|
+ * You may obtain a copy of the License at
|
|
|
+ *
|
|
|
+ * http://www.apache.org/licenses/LICENSE-2.0
|
|
|
+ *
|
|
|
+ * Unless required by applicable law or agreed to in writing, software
|
|
|
+ * distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
+ * WITHOUT WARRANTIES OR 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_ECDCLIENT_H_
|
|
|
+#define ALIBABACLOUD_ECD_ECDCLIENT_H_
|
|
|
+
|
|
|
+#include <future>
|
|
|
+#include <alibabacloud/core/AsyncCallerContext.h>
|
|
|
+#include <alibabacloud/core/EndpointProvider.h>
|
|
|
+#include <alibabacloud/core/RpcServiceClient.h>
|
|
|
+#include "EcdExport.h"
|
|
|
+#include "model/ActivateOfficeSiteRequest.h"
|
|
|
+#include "model/ActivateOfficeSiteResult.h"
|
|
|
+#include "model/AddUserToDesktopGroupRequest.h"
|
|
|
+#include "model/AddUserToDesktopGroupResult.h"
|
|
|
+#include "model/ApplyCoordinatePrivilegeRequest.h"
|
|
|
+#include "model/ApplyCoordinatePrivilegeResult.h"
|
|
|
+#include "model/ApplyCoordinationForMonitoringRequest.h"
|
|
|
+#include "model/ApplyCoordinationForMonitoringResult.h"
|
|
|
+#include "model/ApproveFotaUpdateRequest.h"
|
|
|
+#include "model/ApproveFotaUpdateResult.h"
|
|
|
+#include "model/AssociateNetworkPackageRequest.h"
|
|
|
+#include "model/AssociateNetworkPackageResult.h"
|
|
|
+#include "model/AttachCenRequest.h"
|
|
|
+#include "model/AttachCenResult.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/ConfigADConnectorTrustRequest.h"
|
|
|
+#include "model/ConfigADConnectorTrustResult.h"
|
|
|
+#include "model/ConfigADConnectorUserRequest.h"
|
|
|
+#include "model/ConfigADConnectorUserResult.h"
|
|
|
+#include "model/CopyImageRequest.h"
|
|
|
+#include "model/CopyImageResult.h"
|
|
|
+#include "model/CreateADConnectorDirectoryRequest.h"
|
|
|
+#include "model/CreateADConnectorDirectoryResult.h"
|
|
|
+#include "model/CreateADConnectorOfficeSiteRequest.h"
|
|
|
+#include "model/CreateADConnectorOfficeSiteResult.h"
|
|
|
+#include "model/CreateAndBindNasFileSystemRequest.h"
|
|
|
+#include "model/CreateAndBindNasFileSystemResult.h"
|
|
|
+#include "model/CreateBundleRequest.h"
|
|
|
+#include "model/CreateBundleResult.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"
|
|
|
+#include "model/CreateNASFileSystemResult.h"
|
|
|
+#include "model/CreateNetworkPackageRequest.h"
|
|
|
+#include "model/CreateNetworkPackageResult.h"
|
|
|
+#include "model/CreatePolicyGroupRequest.h"
|
|
|
+#include "model/CreatePolicyGroupResult.h"
|
|
|
+#include "model/CreateRAMDirectoryRequest.h"
|
|
|
+#include "model/CreateRAMDirectoryResult.h"
|
|
|
+#include "model/CreateSimpleOfficeSiteRequest.h"
|
|
|
+#include "model/CreateSimpleOfficeSiteResult.h"
|
|
|
+#include "model/CreateSnapshotRequest.h"
|
|
|
+#include "model/CreateSnapshotResult.h"
|
|
|
+#include "model/DeleteBundlesRequest.h"
|
|
|
+#include "model/DeleteBundlesResult.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/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"
|
|
|
+#include "model/DeleteNASFileSystemsResult.h"
|
|
|
+#include "model/DeleteNetworkPackagesRequest.h"
|
|
|
+#include "model/DeleteNetworkPackagesResult.h"
|
|
|
+#include "model/DeleteOfficeSitesRequest.h"
|
|
|
+#include "model/DeleteOfficeSitesResult.h"
|
|
|
+#include "model/DeletePolicyGroupsRequest.h"
|
|
|
+#include "model/DeletePolicyGroupsResult.h"
|
|
|
+#include "model/DeleteSnapshotRequest.h"
|
|
|
+#include "model/DeleteSnapshotResult.h"
|
|
|
+#include "model/DeleteVirtualMFADeviceRequest.h"
|
|
|
+#include "model/DeleteVirtualMFADeviceResult.h"
|
|
|
+#include "model/DescribeAlarmEventStackInfoRequest.h"
|
|
|
+#include "model/DescribeAlarmEventStackInfoResult.h"
|
|
|
+#include "model/DescribeBundlesRequest.h"
|
|
|
+#include "model/DescribeBundlesResult.h"
|
|
|
+#include "model/DescribeCensRequest.h"
|
|
|
+#include "model/DescribeCensResult.h"
|
|
|
+#include "model/DescribeClientEventsRequest.h"
|
|
|
+#include "model/DescribeClientEventsResult.h"
|
|
|
+#include "model/DescribeCloudDrivePermissionsRequest.h"
|
|
|
+#include "model/DescribeCloudDrivePermissionsResult.h"
|
|
|
+#include "model/DescribeCustomizedListHeadersRequest.h"
|
|
|
+#include "model/DescribeCustomizedListHeadersResult.h"
|
|
|
+#include "model/DescribeDesktopGroupsRequest.h"
|
|
|
+#include "model/DescribeDesktopGroupsResult.h"
|
|
|
+#include "model/DescribeDesktopIdsByVulNamesRequest.h"
|
|
|
+#include "model/DescribeDesktopIdsByVulNamesResult.h"
|
|
|
+#include "model/DescribeDesktopTypesRequest.h"
|
|
|
+#include "model/DescribeDesktopTypesResult.h"
|
|
|
+#include "model/DescribeDesktopsRequest.h"
|
|
|
+#include "model/DescribeDesktopsResult.h"
|
|
|
+#include "model/DescribeDesktopsInGroupRequest.h"
|
|
|
+#include "model/DescribeDesktopsInGroupResult.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"
|
|
|
+#include "model/DescribeFlowStatisticResult.h"
|
|
|
+#include "model/DescribeFotaPendingDesktopsRequest.h"
|
|
|
+#include "model/DescribeFotaPendingDesktopsResult.h"
|
|
|
+#include "model/DescribeFotaTasksRequest.h"
|
|
|
+#include "model/DescribeFotaTasksResult.h"
|
|
|
+#include "model/DescribeFrontVulPatchListRequest.h"
|
|
|
+#include "model/DescribeFrontVulPatchListResult.h"
|
|
|
+#include "model/DescribeGroupedVulRequest.h"
|
|
|
+#include "model/DescribeGroupedVulResult.h"
|
|
|
+#include "model/DescribeImageModifiedRecordsRequest.h"
|
|
|
+#include "model/DescribeImageModifiedRecordsResult.h"
|
|
|
+#include "model/DescribeImagePermissionRequest.h"
|
|
|
+#include "model/DescribeImagePermissionResult.h"
|
|
|
+#include "model/DescribeImagesRequest.h"
|
|
|
+#include "model/DescribeImagesResult.h"
|
|
|
+#include "model/DescribeInvocationsRequest.h"
|
|
|
+#include "model/DescribeInvocationsResult.h"
|
|
|
+#include "model/DescribeKmsKeysRequest.h"
|
|
|
+#include "model/DescribeKmsKeysResult.h"
|
|
|
+#include "model/DescribeNASFileSystemsRequest.h"
|
|
|
+#include "model/DescribeNASFileSystemsResult.h"
|
|
|
+#include "model/DescribeNetworkPackagesRequest.h"
|
|
|
+#include "model/DescribeNetworkPackagesResult.h"
|
|
|
+#include "model/DescribeOfficeSitesRequest.h"
|
|
|
+#include "model/DescribeOfficeSitesResult.h"
|
|
|
+#include "model/DescribePolicyGroupsRequest.h"
|
|
|
+#include "model/DescribePolicyGroupsResult.h"
|
|
|
+#include "model/DescribeRegionsRequest.h"
|
|
|
+#include "model/DescribeRegionsResult.h"
|
|
|
+#include "model/DescribeScanTaskProgressRequest.h"
|
|
|
+#include "model/DescribeScanTaskProgressResult.h"
|
|
|
+#include "model/DescribeSecurityEventOperationStatusRequest.h"
|
|
|
+#include "model/DescribeSecurityEventOperationStatusResult.h"
|
|
|
+#include "model/DescribeSecurityEventOperationsRequest.h"
|
|
|
+#include "model/DescribeSecurityEventOperationsResult.h"
|
|
|
+#include "model/DescribeSnapshotsRequest.h"
|
|
|
+#include "model/DescribeSnapshotsResult.h"
|
|
|
+#include "model/DescribeSuspEventOverviewRequest.h"
|
|
|
+#include "model/DescribeSuspEventOverviewResult.h"
|
|
|
+#include "model/DescribeSuspEventQuaraFilesRequest.h"
|
|
|
+#include "model/DescribeSuspEventQuaraFilesResult.h"
|
|
|
+#include "model/DescribeSuspEventsRequest.h"
|
|
|
+#include "model/DescribeSuspEventsResult.h"
|
|
|
+#include "model/DescribeUserConnectionRecordsRequest.h"
|
|
|
+#include "model/DescribeUserConnectionRecordsResult.h"
|
|
|
+#include "model/DescribeUsersInGroupRequest.h"
|
|
|
+#include "model/DescribeUsersInGroupResult.h"
|
|
|
+#include "model/DescribeUsersPasswordRequest.h"
|
|
|
+#include "model/DescribeUsersPasswordResult.h"
|
|
|
+#include "model/DescribeVirtualMFADevicesRequest.h"
|
|
|
+#include "model/DescribeVirtualMFADevicesResult.h"
|
|
|
+#include "model/DescribeVulDetailsRequest.h"
|
|
|
+#include "model/DescribeVulDetailsResult.h"
|
|
|
+#include "model/DescribeVulListRequest.h"
|
|
|
+#include "model/DescribeVulListResult.h"
|
|
|
+#include "model/DescribeVulOverviewRequest.h"
|
|
|
+#include "model/DescribeVulOverviewResult.h"
|
|
|
+#include "model/DescribeZonesRequest.h"
|
|
|
+#include "model/DescribeZonesResult.h"
|
|
|
+#include "model/DetachCenRequest.h"
|
|
|
+#include "model/DetachCenResult.h"
|
|
|
+#include "model/DisableDesktopsInGroupRequest.h"
|
|
|
+#include "model/DisableDesktopsInGroupResult.h"
|
|
|
+#include "model/DissociateNetworkPackageRequest.h"
|
|
|
+#include "model/DissociateNetworkPackageResult.h"
|
|
|
+#include "model/ExportClientEventsRequest.h"
|
|
|
+#include "model/ExportClientEventsResult.h"
|
|
|
+#include "model/ExportDesktopGroupInfoRequest.h"
|
|
|
+#include "model/ExportDesktopGroupInfoResult.h"
|
|
|
+#include "model/ExportDesktopListInfoRequest.h"
|
|
|
+#include "model/ExportDesktopListInfoResult.h"
|
|
|
+#include "model/GetConnectionTicketRequest.h"
|
|
|
+#include "model/GetConnectionTicketResult.h"
|
|
|
+#include "model/GetDesktopGroupDetailRequest.h"
|
|
|
+#include "model/GetDesktopGroupDetailResult.h"
|
|
|
+#include "model/GetOfficeSiteSsoStatusRequest.h"
|
|
|
+#include "model/GetOfficeSiteSsoStatusResult.h"
|
|
|
+#include "model/GetSpMetadataRequest.h"
|
|
|
+#include "model/GetSpMetadataResult.h"
|
|
|
+#include "model/HandleSecurityEventsRequest.h"
|
|
|
+#include "model/HandleSecurityEventsResult.h"
|
|
|
+#include "model/ListDirectoryUsersRequest.h"
|
|
|
+#include "model/ListDirectoryUsersResult.h"
|
|
|
+#include "model/ListOfficeSiteOverviewRequest.h"
|
|
|
+#include "model/ListOfficeSiteOverviewResult.h"
|
|
|
+#include "model/ListOfficeSiteUsersRequest.h"
|
|
|
+#include "model/ListOfficeSiteUsersResult.h"
|
|
|
+#include "model/ListTagResourcesRequest.h"
|
|
|
+#include "model/ListTagResourcesResult.h"
|
|
|
+#include "model/ListUserAdOrganizationUnitsRequest.h"
|
|
|
+#include "model/ListUserAdOrganizationUnitsResult.h"
|
|
|
+#include "model/LockVirtualMFADeviceRequest.h"
|
|
|
+#include "model/LockVirtualMFADeviceResult.h"
|
|
|
+#include "model/ModifyADConnectorDirectoryRequest.h"
|
|
|
+#include "model/ModifyADConnectorDirectoryResult.h"
|
|
|
+#include "model/ModifyADConnectorOfficeSiteRequest.h"
|
|
|
+#include "model/ModifyADConnectorOfficeSiteResult.h"
|
|
|
+#include "model/ModifyBundleRequest.h"
|
|
|
+#include "model/ModifyBundleResult.h"
|
|
|
+#include "model/ModifyCloudDrivePermissionRequest.h"
|
|
|
+#include "model/ModifyCloudDrivePermissionResult.h"
|
|
|
+#include "model/ModifyCustomizedListHeadersRequest.h"
|
|
|
+#include "model/ModifyCustomizedListHeadersResult.h"
|
|
|
+#include "model/ModifyDesktopChargeTypeRequest.h"
|
|
|
+#include "model/ModifyDesktopChargeTypeResult.h"
|
|
|
+#include "model/ModifyDesktopGroupRequest.h"
|
|
|
+#include "model/ModifyDesktopGroupResult.h"
|
|
|
+#include "model/ModifyDesktopHostNameRequest.h"
|
|
|
+#include "model/ModifyDesktopHostNameResult.h"
|
|
|
+#include "model/ModifyDesktopNameRequest.h"
|
|
|
+#include "model/ModifyDesktopNameResult.h"
|
|
|
+#include "model/ModifyDesktopSpecRequest.h"
|
|
|
+#include "model/ModifyDesktopSpecResult.h"
|
|
|
+#include "model/ModifyDesktopsPolicyGroupRequest.h"
|
|
|
+#include "model/ModifyDesktopsPolicyGroupResult.h"
|
|
|
+#include "model/ModifyDiskSpecRequest.h"
|
|
|
+#include "model/ModifyDiskSpecResult.h"
|
|
|
+#include "model/ModifyEntitlementRequest.h"
|
|
|
+#include "model/ModifyEntitlementResult.h"
|
|
|
+#include "model/ModifyImageAttributeRequest.h"
|
|
|
+#include "model/ModifyImageAttributeResult.h"
|
|
|
+#include "model/ModifyImagePermissionRequest.h"
|
|
|
+#include "model/ModifyImagePermissionResult.h"
|
|
|
+#include "model/ModifyNASDefaultMountTargetRequest.h"
|
|
|
+#include "model/ModifyNASDefaultMountTargetResult.h"
|
|
|
+#include "model/ModifyNetworkPackageBandwidthRequest.h"
|
|
|
+#include "model/ModifyNetworkPackageBandwidthResult.h"
|
|
|
+#include "model/ModifyNetworkPackageEnabledRequest.h"
|
|
|
+#include "model/ModifyNetworkPackageEnabledResult.h"
|
|
|
+#include "model/ModifyOfficeSiteAttributeRequest.h"
|
|
|
+#include "model/ModifyOfficeSiteAttributeResult.h"
|
|
|
+#include "model/ModifyOfficeSiteCrossDesktopAccessRequest.h"
|
|
|
+#include "model/ModifyOfficeSiteCrossDesktopAccessResult.h"
|
|
|
+#include "model/ModifyOfficeSiteMfaEnabledRequest.h"
|
|
|
+#include "model/ModifyOfficeSiteMfaEnabledResult.h"
|
|
|
+#include "model/ModifyOperateVulRequest.h"
|
|
|
+#include "model/ModifyOperateVulResult.h"
|
|
|
+#include "model/ModifyPolicyGroupRequest.h"
|
|
|
+#include "model/ModifyPolicyGroupResult.h"
|
|
|
+#include "model/ModifyUserEntitlementRequest.h"
|
|
|
+#include "model/ModifyUserEntitlementResult.h"
|
|
|
+#include "model/ModifyUserToDesktopGroupRequest.h"
|
|
|
+#include "model/ModifyUserToDesktopGroupResult.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/RemoveUserFromDesktopGroupRequest.h"
|
|
|
+#include "model/RemoveUserFromDesktopGroupResult.h"
|
|
|
+#include "model/RenewDesktopsRequest.h"
|
|
|
+#include "model/RenewDesktopsResult.h"
|
|
|
+#include "model/RenewNetworkPackagesRequest.h"
|
|
|
+#include "model/RenewNetworkPackagesResult.h"
|
|
|
+#include "model/ResetDesktopsRequest.h"
|
|
|
+#include "model/ResetDesktopsResult.h"
|
|
|
+#include "model/ResetNASDefaultMountTargetRequest.h"
|
|
|
+#include "model/ResetNASDefaultMountTargetResult.h"
|
|
|
+#include "model/ResetSnapshotRequest.h"
|
|
|
+#include "model/ResetSnapshotResult.h"
|
|
|
+#include "model/RevokeCoordinatePrivilegeRequest.h"
|
|
|
+#include "model/RevokeCoordinatePrivilegeResult.h"
|
|
|
+#include "model/RollbackSuspEventQuaraFileRequest.h"
|
|
|
+#include "model/RollbackSuspEventQuaraFileResult.h"
|
|
|
+#include "model/RunCommandRequest.h"
|
|
|
+#include "model/RunCommandResult.h"
|
|
|
+#include "model/SendVerifyCodeRequest.h"
|
|
|
+#include "model/SendVerifyCodeResult.h"
|
|
|
+#include "model/SetDesktopGroupTimerRequest.h"
|
|
|
+#include "model/SetDesktopGroupTimerResult.h"
|
|
|
+#include "model/SetDesktopGroupTimerStatusRequest.h"
|
|
|
+#include "model/SetDesktopGroupTimerStatusResult.h"
|
|
|
+#include "model/SetIdpMetadataRequest.h"
|
|
|
+#include "model/SetIdpMetadataResult.h"
|
|
|
+#include "model/SetOfficeSiteSsoStatusRequest.h"
|
|
|
+#include "model/SetOfficeSiteSsoStatusResult.h"
|
|
|
+#include "model/StartDesktopsRequest.h"
|
|
|
+#include "model/StartDesktopsResult.h"
|
|
|
+#include "model/StartVirusScanTaskRequest.h"
|
|
|
+#include "model/StartVirusScanTaskResult.h"
|
|
|
+#include "model/StopDesktopsRequest.h"
|
|
|
+#include "model/StopDesktopsResult.h"
|
|
|
+#include "model/StopInvocationRequest.h"
|
|
|
+#include "model/StopInvocationResult.h"
|
|
|
+#include "model/TagResourcesRequest.h"
|
|
|
+#include "model/TagResourcesResult.h"
|
|
|
+#include "model/UnlockVirtualMFADeviceRequest.h"
|
|
|
+#include "model/UnlockVirtualMFADeviceResult.h"
|
|
|
+#include "model/UntagResourcesRequest.h"
|
|
|
+#include "model/UntagResourcesResult.h"
|
|
|
+#include "model/UpdateFotaTaskRequest.h"
|
|
|
+#include "model/UpdateFotaTaskResult.h"
|
|
|
+#include "model/UploadImageRequest.h"
|
|
|
+#include "model/UploadImageResult.h"
|
|
|
+#include "model/VerifyCenRequest.h"
|
|
|
+#include "model/VerifyCenResult.h"
|
|
|
+
|
|
|
+
|
|
|
+namespace AlibabaCloud
|
|
|
+{
|
|
|
+ namespace Ecd
|
|
|
+ {
|
|
|
+ class ALIBABACLOUD_ECD_EXPORT EcdClient : public RpcServiceClient
|
|
|
+ {
|
|
|
+ public:
|
|
|
+ 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::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::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;
|
|
|
+ typedef Outcome<Error, Model::ApplyCoordinationForMonitoringResult> ApplyCoordinationForMonitoringOutcome;
|
|
|
+ typedef std::future<ApplyCoordinationForMonitoringOutcome> ApplyCoordinationForMonitoringOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ApplyCoordinationForMonitoringRequest&, const ApplyCoordinationForMonitoringOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApplyCoordinationForMonitoringAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ApproveFotaUpdateResult> ApproveFotaUpdateOutcome;
|
|
|
+ typedef std::future<ApproveFotaUpdateOutcome> ApproveFotaUpdateOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ApproveFotaUpdateRequest&, const ApproveFotaUpdateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ApproveFotaUpdateAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::AssociateNetworkPackageResult> AssociateNetworkPackageOutcome;
|
|
|
+ typedef std::future<AssociateNetworkPackageOutcome> AssociateNetworkPackageOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::AssociateNetworkPackageRequest&, const AssociateNetworkPackageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AssociateNetworkPackageAsyncHandler;
|
|
|
+ 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::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;
|
|
|
+ typedef Outcome<Error, Model::CancelCopyImageResult> CancelCopyImageOutcome;
|
|
|
+ typedef std::future<CancelCopyImageOutcome> CancelCopyImageOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::CancelCopyImageRequest&, const CancelCopyImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelCopyImageAsyncHandler;
|
|
|
+ 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::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::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;
|
|
|
+ typedef Outcome<Error, Model::CreateADConnectorDirectoryResult> CreateADConnectorDirectoryOutcome;
|
|
|
+ typedef std::future<CreateADConnectorDirectoryOutcome> CreateADConnectorDirectoryOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::CreateADConnectorDirectoryRequest&, const CreateADConnectorDirectoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateADConnectorDirectoryAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::CreateADConnectorOfficeSiteResult> CreateADConnectorOfficeSiteOutcome;
|
|
|
+ typedef std::future<CreateADConnectorOfficeSiteOutcome> CreateADConnectorOfficeSiteOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::CreateADConnectorOfficeSiteRequest&, const CreateADConnectorOfficeSiteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateADConnectorOfficeSiteAsyncHandler;
|
|
|
+ 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::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::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;
|
|
|
+ typedef Outcome<Error, Model::CreateDesktopsResult> CreateDesktopsOutcome;
|
|
|
+ typedef std::future<CreateDesktopsOutcome> CreateDesktopsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::CreateDesktopsRequest&, const CreateDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDesktopsAsyncHandler;
|
|
|
+ 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;
|
|
|
+ typedef Outcome<Error, Model::CreateNASFileSystemResult> CreateNASFileSystemOutcome;
|
|
|
+ typedef std::future<CreateNASFileSystemOutcome> CreateNASFileSystemOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::CreateNASFileSystemRequest&, const CreateNASFileSystemOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNASFileSystemAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::CreateNetworkPackageResult> CreateNetworkPackageOutcome;
|
|
|
+ typedef std::future<CreateNetworkPackageOutcome> CreateNetworkPackageOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::CreateNetworkPackageRequest&, const CreateNetworkPackageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNetworkPackageAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::CreatePolicyGroupResult> CreatePolicyGroupOutcome;
|
|
|
+ typedef std::future<CreatePolicyGroupOutcome> CreatePolicyGroupOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::CreatePolicyGroupRequest&, const CreatePolicyGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePolicyGroupAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::CreateRAMDirectoryResult> CreateRAMDirectoryOutcome;
|
|
|
+ typedef std::future<CreateRAMDirectoryOutcome> CreateRAMDirectoryOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::CreateRAMDirectoryRequest&, const CreateRAMDirectoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateRAMDirectoryAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::CreateSimpleOfficeSiteResult> CreateSimpleOfficeSiteOutcome;
|
|
|
+ typedef std::future<CreateSimpleOfficeSiteOutcome> CreateSimpleOfficeSiteOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::CreateSimpleOfficeSiteRequest&, const CreateSimpleOfficeSiteOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSimpleOfficeSiteAsyncHandler;
|
|
|
+ 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::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::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;
|
|
|
+ typedef Outcome<Error, Model::DeleteDesktopGroupResult> DeleteDesktopGroupOutcome;
|
|
|
+ typedef std::future<DeleteDesktopGroupOutcome> DeleteDesktopGroupOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DeleteDesktopGroupRequest&, const DeleteDesktopGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDesktopGroupAsyncHandler;
|
|
|
+ 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::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;
|
|
|
+ typedef Outcome<Error, Model::DeleteNASFileSystemsResult> DeleteNASFileSystemsOutcome;
|
|
|
+ typedef std::future<DeleteNASFileSystemsOutcome> DeleteNASFileSystemsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DeleteNASFileSystemsRequest&, const DeleteNASFileSystemsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNASFileSystemsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DeleteNetworkPackagesResult> DeleteNetworkPackagesOutcome;
|
|
|
+ typedef std::future<DeleteNetworkPackagesOutcome> DeleteNetworkPackagesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DeleteNetworkPackagesRequest&, const DeleteNetworkPackagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNetworkPackagesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DeleteOfficeSitesResult> DeleteOfficeSitesOutcome;
|
|
|
+ typedef std::future<DeleteOfficeSitesOutcome> DeleteOfficeSitesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DeleteOfficeSitesRequest&, const DeleteOfficeSitesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteOfficeSitesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DeletePolicyGroupsResult> DeletePolicyGroupsOutcome;
|
|
|
+ typedef std::future<DeletePolicyGroupsOutcome> DeletePolicyGroupsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DeletePolicyGroupsRequest&, const DeletePolicyGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePolicyGroupsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DeleteSnapshotResult> DeleteSnapshotOutcome;
|
|
|
+ typedef std::future<DeleteSnapshotOutcome> DeleteSnapshotOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DeleteSnapshotRequest&, const DeleteSnapshotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSnapshotAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DeleteVirtualMFADeviceResult> DeleteVirtualMFADeviceOutcome;
|
|
|
+ typedef std::future<DeleteVirtualMFADeviceOutcome> DeleteVirtualMFADeviceOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DeleteVirtualMFADeviceRequest&, const DeleteVirtualMFADeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVirtualMFADeviceAsyncHandler;
|
|
|
+ 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::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::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::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;
|
|
|
+ typedef Outcome<Error, Model::DescribeCustomizedListHeadersResult> DescribeCustomizedListHeadersOutcome;
|
|
|
+ typedef std::future<DescribeCustomizedListHeadersOutcome> DescribeCustomizedListHeadersOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeCustomizedListHeadersRequest&, const DescribeCustomizedListHeadersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCustomizedListHeadersAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeDesktopGroupsResult> DescribeDesktopGroupsOutcome;
|
|
|
+ typedef std::future<DescribeDesktopGroupsOutcome> DescribeDesktopGroupsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeDesktopGroupsRequest&, const DescribeDesktopGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDesktopGroupsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeDesktopIdsByVulNamesResult> DescribeDesktopIdsByVulNamesOutcome;
|
|
|
+ typedef std::future<DescribeDesktopIdsByVulNamesOutcome> DescribeDesktopIdsByVulNamesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeDesktopIdsByVulNamesRequest&, const DescribeDesktopIdsByVulNamesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDesktopIdsByVulNamesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeDesktopTypesResult> DescribeDesktopTypesOutcome;
|
|
|
+ typedef std::future<DescribeDesktopTypesOutcome> DescribeDesktopTypesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeDesktopTypesRequest&, const DescribeDesktopTypesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDesktopTypesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeDesktopsResult> DescribeDesktopsOutcome;
|
|
|
+ typedef std::future<DescribeDesktopsOutcome> DescribeDesktopsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeDesktopsRequest&, const DescribeDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDesktopsAsyncHandler;
|
|
|
+ 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::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;
|
|
|
+ typedef Outcome<Error, Model::DescribeFlowStatisticResult> DescribeFlowStatisticOutcome;
|
|
|
+ typedef std::future<DescribeFlowStatisticOutcome> DescribeFlowStatisticOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeFlowStatisticRequest&, const DescribeFlowStatisticOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFlowStatisticAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeFotaPendingDesktopsResult> DescribeFotaPendingDesktopsOutcome;
|
|
|
+ typedef std::future<DescribeFotaPendingDesktopsOutcome> DescribeFotaPendingDesktopsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeFotaPendingDesktopsRequest&, const DescribeFotaPendingDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFotaPendingDesktopsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeFotaTasksResult> DescribeFotaTasksOutcome;
|
|
|
+ typedef std::future<DescribeFotaTasksOutcome> DescribeFotaTasksOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeFotaTasksRequest&, const DescribeFotaTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFotaTasksAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeFrontVulPatchListResult> DescribeFrontVulPatchListOutcome;
|
|
|
+ typedef std::future<DescribeFrontVulPatchListOutcome> DescribeFrontVulPatchListOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeFrontVulPatchListRequest&, const DescribeFrontVulPatchListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeFrontVulPatchListAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeGroupedVulResult> DescribeGroupedVulOutcome;
|
|
|
+ typedef std::future<DescribeGroupedVulOutcome> DescribeGroupedVulOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeGroupedVulRequest&, const DescribeGroupedVulOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGroupedVulAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeImageModifiedRecordsResult> DescribeImageModifiedRecordsOutcome;
|
|
|
+ typedef std::future<DescribeImageModifiedRecordsOutcome> DescribeImageModifiedRecordsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeImageModifiedRecordsRequest&, const DescribeImageModifiedRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImageModifiedRecordsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeImagePermissionResult> DescribeImagePermissionOutcome;
|
|
|
+ typedef std::future<DescribeImagePermissionOutcome> DescribeImagePermissionOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeImagePermissionRequest&, const DescribeImagePermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImagePermissionAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeImagesResult> DescribeImagesOutcome;
|
|
|
+ typedef std::future<DescribeImagesOutcome> DescribeImagesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeImagesRequest&, const DescribeImagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeImagesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeInvocationsResult> DescribeInvocationsOutcome;
|
|
|
+ typedef std::future<DescribeInvocationsOutcome> DescribeInvocationsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeInvocationsRequest&, const DescribeInvocationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInvocationsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeKmsKeysResult> DescribeKmsKeysOutcome;
|
|
|
+ typedef std::future<DescribeKmsKeysOutcome> DescribeKmsKeysOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeKmsKeysRequest&, const DescribeKmsKeysOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeKmsKeysAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeNASFileSystemsResult> DescribeNASFileSystemsOutcome;
|
|
|
+ typedef std::future<DescribeNASFileSystemsOutcome> DescribeNASFileSystemsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeNASFileSystemsRequest&, const DescribeNASFileSystemsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNASFileSystemsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeNetworkPackagesResult> DescribeNetworkPackagesOutcome;
|
|
|
+ typedef std::future<DescribeNetworkPackagesOutcome> DescribeNetworkPackagesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeNetworkPackagesRequest&, const DescribeNetworkPackagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeNetworkPackagesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeOfficeSitesResult> DescribeOfficeSitesOutcome;
|
|
|
+ typedef std::future<DescribeOfficeSitesOutcome> DescribeOfficeSitesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeOfficeSitesRequest&, const DescribeOfficeSitesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeOfficeSitesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribePolicyGroupsResult> DescribePolicyGroupsOutcome;
|
|
|
+ typedef std::future<DescribePolicyGroupsOutcome> DescribePolicyGroupsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribePolicyGroupsRequest&, const DescribePolicyGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePolicyGroupsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
|
|
|
+ typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeScanTaskProgressResult> DescribeScanTaskProgressOutcome;
|
|
|
+ typedef std::future<DescribeScanTaskProgressOutcome> DescribeScanTaskProgressOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeScanTaskProgressRequest&, const DescribeScanTaskProgressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScanTaskProgressAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeSecurityEventOperationStatusResult> DescribeSecurityEventOperationStatusOutcome;
|
|
|
+ typedef std::future<DescribeSecurityEventOperationStatusOutcome> DescribeSecurityEventOperationStatusOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeSecurityEventOperationStatusRequest&, const DescribeSecurityEventOperationStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSecurityEventOperationStatusAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeSecurityEventOperationsResult> DescribeSecurityEventOperationsOutcome;
|
|
|
+ typedef std::future<DescribeSecurityEventOperationsOutcome> DescribeSecurityEventOperationsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeSecurityEventOperationsRequest&, const DescribeSecurityEventOperationsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSecurityEventOperationsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeSnapshotsResult> DescribeSnapshotsOutcome;
|
|
|
+ typedef std::future<DescribeSnapshotsOutcome> DescribeSnapshotsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeSnapshotsRequest&, const DescribeSnapshotsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSnapshotsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeSuspEventOverviewResult> DescribeSuspEventOverviewOutcome;
|
|
|
+ typedef std::future<DescribeSuspEventOverviewOutcome> DescribeSuspEventOverviewOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeSuspEventOverviewRequest&, const DescribeSuspEventOverviewOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSuspEventOverviewAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeSuspEventQuaraFilesResult> DescribeSuspEventQuaraFilesOutcome;
|
|
|
+ typedef std::future<DescribeSuspEventQuaraFilesOutcome> DescribeSuspEventQuaraFilesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeSuspEventQuaraFilesRequest&, const DescribeSuspEventQuaraFilesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSuspEventQuaraFilesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeSuspEventsResult> DescribeSuspEventsOutcome;
|
|
|
+ typedef std::future<DescribeSuspEventsOutcome> DescribeSuspEventsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeSuspEventsRequest&, const DescribeSuspEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSuspEventsAsyncHandler;
|
|
|
+ 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::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;
|
|
|
+ typedef Outcome<Error, Model::DescribeUsersPasswordResult> DescribeUsersPasswordOutcome;
|
|
|
+ typedef std::future<DescribeUsersPasswordOutcome> DescribeUsersPasswordOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeUsersPasswordRequest&, const DescribeUsersPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUsersPasswordAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeVirtualMFADevicesResult> DescribeVirtualMFADevicesOutcome;
|
|
|
+ typedef std::future<DescribeVirtualMFADevicesOutcome> DescribeVirtualMFADevicesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeVirtualMFADevicesRequest&, const DescribeVirtualMFADevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVirtualMFADevicesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeVulDetailsResult> DescribeVulDetailsOutcome;
|
|
|
+ typedef std::future<DescribeVulDetailsOutcome> DescribeVulDetailsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeVulDetailsRequest&, const DescribeVulDetailsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVulDetailsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeVulListResult> DescribeVulListOutcome;
|
|
|
+ typedef std::future<DescribeVulListOutcome> DescribeVulListOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeVulListRequest&, const DescribeVulListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVulListAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeVulOverviewResult> DescribeVulOverviewOutcome;
|
|
|
+ typedef std::future<DescribeVulOverviewOutcome> DescribeVulOverviewOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeVulOverviewRequest&, const DescribeVulOverviewOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVulOverviewAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::DescribeZonesResult> DescribeZonesOutcome;
|
|
|
+ typedef std::future<DescribeZonesOutcome> DescribeZonesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DescribeZonesRequest&, const DescribeZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeZonesAsyncHandler;
|
|
|
+ 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::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;
|
|
|
+ typedef Outcome<Error, Model::DissociateNetworkPackageResult> DissociateNetworkPackageOutcome;
|
|
|
+ typedef std::future<DissociateNetworkPackageOutcome> DissociateNetworkPackageOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::DissociateNetworkPackageRequest&, const DissociateNetworkPackageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DissociateNetworkPackageAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ExportClientEventsResult> ExportClientEventsOutcome;
|
|
|
+ typedef std::future<ExportClientEventsOutcome> ExportClientEventsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ExportClientEventsRequest&, const ExportClientEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportClientEventsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ExportDesktopGroupInfoResult> ExportDesktopGroupInfoOutcome;
|
|
|
+ typedef std::future<ExportDesktopGroupInfoOutcome> ExportDesktopGroupInfoOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ExportDesktopGroupInfoRequest&, const ExportDesktopGroupInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportDesktopGroupInfoAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ExportDesktopListInfoResult> ExportDesktopListInfoOutcome;
|
|
|
+ typedef std::future<ExportDesktopListInfoOutcome> ExportDesktopListInfoOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ExportDesktopListInfoRequest&, const ExportDesktopListInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExportDesktopListInfoAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::GetConnectionTicketResult> GetConnectionTicketOutcome;
|
|
|
+ typedef std::future<GetConnectionTicketOutcome> GetConnectionTicketOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::GetConnectionTicketRequest&, const GetConnectionTicketOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetConnectionTicketAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::GetDesktopGroupDetailResult> GetDesktopGroupDetailOutcome;
|
|
|
+ typedef std::future<GetDesktopGroupDetailOutcome> GetDesktopGroupDetailOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::GetDesktopGroupDetailRequest&, const GetDesktopGroupDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDesktopGroupDetailAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::GetOfficeSiteSsoStatusResult> GetOfficeSiteSsoStatusOutcome;
|
|
|
+ typedef std::future<GetOfficeSiteSsoStatusOutcome> GetOfficeSiteSsoStatusOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::GetOfficeSiteSsoStatusRequest&, const GetOfficeSiteSsoStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetOfficeSiteSsoStatusAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::GetSpMetadataResult> GetSpMetadataOutcome;
|
|
|
+ typedef std::future<GetSpMetadataOutcome> GetSpMetadataOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::GetSpMetadataRequest&, const GetSpMetadataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetSpMetadataAsyncHandler;
|
|
|
+ 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::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::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;
|
|
|
+ typedef Outcome<Error, Model::ListOfficeSiteUsersResult> ListOfficeSiteUsersOutcome;
|
|
|
+ typedef std::future<ListOfficeSiteUsersOutcome> ListOfficeSiteUsersOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ListOfficeSiteUsersRequest&, const ListOfficeSiteUsersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListOfficeSiteUsersAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
|
|
|
+ typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ListUserAdOrganizationUnitsResult> ListUserAdOrganizationUnitsOutcome;
|
|
|
+ typedef std::future<ListUserAdOrganizationUnitsOutcome> ListUserAdOrganizationUnitsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ListUserAdOrganizationUnitsRequest&, const ListUserAdOrganizationUnitsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListUserAdOrganizationUnitsAsyncHandler;
|
|
|
+ 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::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::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::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;
|
|
|
+ typedef Outcome<Error, Model::ModifyCustomizedListHeadersResult> ModifyCustomizedListHeadersOutcome;
|
|
|
+ typedef std::future<ModifyCustomizedListHeadersOutcome> ModifyCustomizedListHeadersOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyCustomizedListHeadersRequest&, const ModifyCustomizedListHeadersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCustomizedListHeadersAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyDesktopChargeTypeResult> ModifyDesktopChargeTypeOutcome;
|
|
|
+ typedef std::future<ModifyDesktopChargeTypeOutcome> ModifyDesktopChargeTypeOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyDesktopChargeTypeRequest&, const ModifyDesktopChargeTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDesktopChargeTypeAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyDesktopGroupResult> ModifyDesktopGroupOutcome;
|
|
|
+ typedef std::future<ModifyDesktopGroupOutcome> ModifyDesktopGroupOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyDesktopGroupRequest&, const ModifyDesktopGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDesktopGroupAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyDesktopHostNameResult> ModifyDesktopHostNameOutcome;
|
|
|
+ typedef std::future<ModifyDesktopHostNameOutcome> ModifyDesktopHostNameOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyDesktopHostNameRequest&, const ModifyDesktopHostNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDesktopHostNameAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyDesktopNameResult> ModifyDesktopNameOutcome;
|
|
|
+ typedef std::future<ModifyDesktopNameOutcome> ModifyDesktopNameOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyDesktopNameRequest&, const ModifyDesktopNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDesktopNameAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyDesktopSpecResult> ModifyDesktopSpecOutcome;
|
|
|
+ typedef std::future<ModifyDesktopSpecOutcome> ModifyDesktopSpecOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyDesktopSpecRequest&, const ModifyDesktopSpecOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDesktopSpecAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyDesktopsPolicyGroupResult> ModifyDesktopsPolicyGroupOutcome;
|
|
|
+ typedef std::future<ModifyDesktopsPolicyGroupOutcome> ModifyDesktopsPolicyGroupOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyDesktopsPolicyGroupRequest&, const ModifyDesktopsPolicyGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDesktopsPolicyGroupAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyDiskSpecResult> ModifyDiskSpecOutcome;
|
|
|
+ typedef std::future<ModifyDiskSpecOutcome> ModifyDiskSpecOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyDiskSpecRequest&, const ModifyDiskSpecOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDiskSpecAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyEntitlementResult> ModifyEntitlementOutcome;
|
|
|
+ typedef std::future<ModifyEntitlementOutcome> ModifyEntitlementOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyEntitlementRequest&, const ModifyEntitlementOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyEntitlementAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyImageAttributeResult> ModifyImageAttributeOutcome;
|
|
|
+ typedef std::future<ModifyImageAttributeOutcome> ModifyImageAttributeOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyImageAttributeRequest&, const ModifyImageAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyImageAttributeAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyImagePermissionResult> ModifyImagePermissionOutcome;
|
|
|
+ typedef std::future<ModifyImagePermissionOutcome> ModifyImagePermissionOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyImagePermissionRequest&, const ModifyImagePermissionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyImagePermissionAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyNASDefaultMountTargetResult> ModifyNASDefaultMountTargetOutcome;
|
|
|
+ typedef std::future<ModifyNASDefaultMountTargetOutcome> ModifyNASDefaultMountTargetOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyNASDefaultMountTargetRequest&, const ModifyNASDefaultMountTargetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyNASDefaultMountTargetAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyNetworkPackageBandwidthResult> ModifyNetworkPackageBandwidthOutcome;
|
|
|
+ typedef std::future<ModifyNetworkPackageBandwidthOutcome> ModifyNetworkPackageBandwidthOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyNetworkPackageBandwidthRequest&, const ModifyNetworkPackageBandwidthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyNetworkPackageBandwidthAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyNetworkPackageEnabledResult> ModifyNetworkPackageEnabledOutcome;
|
|
|
+ typedef std::future<ModifyNetworkPackageEnabledOutcome> ModifyNetworkPackageEnabledOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyNetworkPackageEnabledRequest&, const ModifyNetworkPackageEnabledOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyNetworkPackageEnabledAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyOfficeSiteAttributeResult> ModifyOfficeSiteAttributeOutcome;
|
|
|
+ typedef std::future<ModifyOfficeSiteAttributeOutcome> ModifyOfficeSiteAttributeOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyOfficeSiteAttributeRequest&, const ModifyOfficeSiteAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyOfficeSiteAttributeAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyOfficeSiteCrossDesktopAccessResult> ModifyOfficeSiteCrossDesktopAccessOutcome;
|
|
|
+ typedef std::future<ModifyOfficeSiteCrossDesktopAccessOutcome> ModifyOfficeSiteCrossDesktopAccessOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyOfficeSiteCrossDesktopAccessRequest&, const ModifyOfficeSiteCrossDesktopAccessOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyOfficeSiteCrossDesktopAccessAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyOfficeSiteMfaEnabledResult> ModifyOfficeSiteMfaEnabledOutcome;
|
|
|
+ typedef std::future<ModifyOfficeSiteMfaEnabledOutcome> ModifyOfficeSiteMfaEnabledOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyOfficeSiteMfaEnabledRequest&, const ModifyOfficeSiteMfaEnabledOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyOfficeSiteMfaEnabledAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyOperateVulResult> ModifyOperateVulOutcome;
|
|
|
+ typedef std::future<ModifyOperateVulOutcome> ModifyOperateVulOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyOperateVulRequest&, const ModifyOperateVulOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyOperateVulAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyPolicyGroupResult> ModifyPolicyGroupOutcome;
|
|
|
+ typedef std::future<ModifyPolicyGroupOutcome> ModifyPolicyGroupOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyPolicyGroupRequest&, const ModifyPolicyGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyPolicyGroupAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ModifyUserEntitlementResult> ModifyUserEntitlementOutcome;
|
|
|
+ typedef std::future<ModifyUserEntitlementOutcome> ModifyUserEntitlementOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ModifyUserEntitlementRequest&, const ModifyUserEntitlementOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyUserEntitlementAsyncHandler;
|
|
|
+ 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::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;
|
|
|
+ typedef Outcome<Error, Model::RebootDesktopsResult> RebootDesktopsOutcome;
|
|
|
+ typedef std::future<RebootDesktopsOutcome> RebootDesktopsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::RebootDesktopsRequest&, const RebootDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RebootDesktopsAsyncHandler;
|
|
|
+ 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::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;
|
|
|
+ typedef Outcome<Error, Model::RenewDesktopsResult> RenewDesktopsOutcome;
|
|
|
+ typedef std::future<RenewDesktopsOutcome> RenewDesktopsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::RenewDesktopsRequest&, const RenewDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RenewDesktopsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::RenewNetworkPackagesResult> RenewNetworkPackagesOutcome;
|
|
|
+ typedef std::future<RenewNetworkPackagesOutcome> RenewNetworkPackagesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::RenewNetworkPackagesRequest&, const RenewNetworkPackagesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RenewNetworkPackagesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ResetDesktopsResult> ResetDesktopsOutcome;
|
|
|
+ typedef std::future<ResetDesktopsOutcome> ResetDesktopsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ResetDesktopsRequest&, const ResetDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetDesktopsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ResetNASDefaultMountTargetResult> ResetNASDefaultMountTargetOutcome;
|
|
|
+ typedef std::future<ResetNASDefaultMountTargetOutcome> ResetNASDefaultMountTargetOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ResetNASDefaultMountTargetRequest&, const ResetNASDefaultMountTargetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetNASDefaultMountTargetAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::ResetSnapshotResult> ResetSnapshotOutcome;
|
|
|
+ typedef std::future<ResetSnapshotOutcome> ResetSnapshotOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::ResetSnapshotRequest&, const ResetSnapshotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetSnapshotAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::RevokeCoordinatePrivilegeResult> RevokeCoordinatePrivilegeOutcome;
|
|
|
+ typedef std::future<RevokeCoordinatePrivilegeOutcome> RevokeCoordinatePrivilegeOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::RevokeCoordinatePrivilegeRequest&, const RevokeCoordinatePrivilegeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RevokeCoordinatePrivilegeAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::RollbackSuspEventQuaraFileResult> RollbackSuspEventQuaraFileOutcome;
|
|
|
+ typedef std::future<RollbackSuspEventQuaraFileOutcome> RollbackSuspEventQuaraFileOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::RollbackSuspEventQuaraFileRequest&, const RollbackSuspEventQuaraFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RollbackSuspEventQuaraFileAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::RunCommandResult> RunCommandOutcome;
|
|
|
+ typedef std::future<RunCommandOutcome> RunCommandOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::RunCommandRequest&, const RunCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunCommandAsyncHandler;
|
|
|
+ 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::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::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::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;
|
|
|
+ typedef Outcome<Error, Model::StartVirusScanTaskResult> StartVirusScanTaskOutcome;
|
|
|
+ typedef std::future<StartVirusScanTaskOutcome> StartVirusScanTaskOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::StartVirusScanTaskRequest&, const StartVirusScanTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartVirusScanTaskAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::StopDesktopsResult> StopDesktopsOutcome;
|
|
|
+ typedef std::future<StopDesktopsOutcome> StopDesktopsOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::StopDesktopsRequest&, const StopDesktopsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopDesktopsAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::StopInvocationResult> StopInvocationOutcome;
|
|
|
+ typedef std::future<StopInvocationOutcome> StopInvocationOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::StopInvocationRequest&, const StopInvocationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopInvocationAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
|
|
|
+ typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::UnlockVirtualMFADeviceResult> UnlockVirtualMFADeviceOutcome;
|
|
|
+ typedef std::future<UnlockVirtualMFADeviceOutcome> UnlockVirtualMFADeviceOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::UnlockVirtualMFADeviceRequest&, const UnlockVirtualMFADeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnlockVirtualMFADeviceAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::UntagResourcesResult> UntagResourcesOutcome;
|
|
|
+ typedef std::future<UntagResourcesOutcome> UntagResourcesOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::UntagResourcesRequest&, const UntagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourcesAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::UpdateFotaTaskResult> UpdateFotaTaskOutcome;
|
|
|
+ typedef std::future<UpdateFotaTaskOutcome> UpdateFotaTaskOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::UpdateFotaTaskRequest&, const UpdateFotaTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateFotaTaskAsyncHandler;
|
|
|
+ typedef Outcome<Error, Model::UploadImageResult> UploadImageOutcome;
|
|
|
+ typedef std::future<UploadImageOutcome> UploadImageOutcomeCallable;
|
|
|
+ typedef std::function<void(const EcdClient*, const Model::UploadImageRequest&, const UploadImageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UploadImageAsyncHandler;
|
|
|
+ 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;
|
|
|
+
|
|
|
+ EcdClient(const Credentials &credentials, const ClientConfiguration &configuration);
|
|
|
+ EcdClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
|
|
|
+ EcdClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
|
|
|
+ ~EcdClient();
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ ApplyCoordinationForMonitoringOutcome applyCoordinationForMonitoring(const Model::ApplyCoordinationForMonitoringRequest &request)const;
|
|
|
+ void applyCoordinationForMonitoringAsync(const Model::ApplyCoordinationForMonitoringRequest& request, const ApplyCoordinationForMonitoringAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ApplyCoordinationForMonitoringOutcomeCallable applyCoordinationForMonitoringCallable(const Model::ApplyCoordinationForMonitoringRequest& request) const;
|
|
|
+ ApproveFotaUpdateOutcome approveFotaUpdate(const Model::ApproveFotaUpdateRequest &request)const;
|
|
|
+ void approveFotaUpdateAsync(const Model::ApproveFotaUpdateRequest& request, const ApproveFotaUpdateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ApproveFotaUpdateOutcomeCallable approveFotaUpdateCallable(const Model::ApproveFotaUpdateRequest& request) const;
|
|
|
+ AssociateNetworkPackageOutcome associateNetworkPackage(const Model::AssociateNetworkPackageRequest &request)const;
|
|
|
+ void associateNetworkPackageAsync(const Model::AssociateNetworkPackageRequest& request, const AssociateNetworkPackageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ AssociateNetworkPackageOutcomeCallable associateNetworkPackageCallable(const Model::AssociateNetworkPackageRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ CancelCopyImageOutcome cancelCopyImage(const Model::CancelCopyImageRequest &request)const;
|
|
|
+ void cancelCopyImageAsync(const Model::CancelCopyImageRequest& request, const CancelCopyImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ CancelCopyImageOutcomeCallable cancelCopyImageCallable(const Model::CancelCopyImageRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ CreateADConnectorDirectoryOutcome createADConnectorDirectory(const Model::CreateADConnectorDirectoryRequest &request)const;
|
|
|
+ void createADConnectorDirectoryAsync(const Model::CreateADConnectorDirectoryRequest& request, const CreateADConnectorDirectoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ CreateADConnectorDirectoryOutcomeCallable createADConnectorDirectoryCallable(const Model::CreateADConnectorDirectoryRequest& request) const;
|
|
|
+ CreateADConnectorOfficeSiteOutcome createADConnectorOfficeSite(const Model::CreateADConnectorOfficeSiteRequest &request)const;
|
|
|
+ void createADConnectorOfficeSiteAsync(const Model::CreateADConnectorOfficeSiteRequest& request, const CreateADConnectorOfficeSiteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ CreateADConnectorOfficeSiteOutcomeCallable createADConnectorOfficeSiteCallable(const Model::CreateADConnectorOfficeSiteRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ CreateDesktopsOutcome createDesktops(const Model::CreateDesktopsRequest &request)const;
|
|
|
+ void createDesktopsAsync(const Model::CreateDesktopsRequest& request, const CreateDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ CreateDesktopsOutcomeCallable createDesktopsCallable(const Model::CreateDesktopsRequest& request) const;
|
|
|
+ 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;
|
|
|
+ CreateNASFileSystemOutcome createNASFileSystem(const Model::CreateNASFileSystemRequest &request)const;
|
|
|
+ void createNASFileSystemAsync(const Model::CreateNASFileSystemRequest& request, const CreateNASFileSystemAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ CreateNASFileSystemOutcomeCallable createNASFileSystemCallable(const Model::CreateNASFileSystemRequest& request) const;
|
|
|
+ CreateNetworkPackageOutcome createNetworkPackage(const Model::CreateNetworkPackageRequest &request)const;
|
|
|
+ void createNetworkPackageAsync(const Model::CreateNetworkPackageRequest& request, const CreateNetworkPackageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ CreateNetworkPackageOutcomeCallable createNetworkPackageCallable(const Model::CreateNetworkPackageRequest& request) const;
|
|
|
+ CreatePolicyGroupOutcome createPolicyGroup(const Model::CreatePolicyGroupRequest &request)const;
|
|
|
+ void createPolicyGroupAsync(const Model::CreatePolicyGroupRequest& request, const CreatePolicyGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ CreatePolicyGroupOutcomeCallable createPolicyGroupCallable(const Model::CreatePolicyGroupRequest& request) const;
|
|
|
+ CreateRAMDirectoryOutcome createRAMDirectory(const Model::CreateRAMDirectoryRequest &request)const;
|
|
|
+ void createRAMDirectoryAsync(const Model::CreateRAMDirectoryRequest& request, const CreateRAMDirectoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ CreateRAMDirectoryOutcomeCallable createRAMDirectoryCallable(const Model::CreateRAMDirectoryRequest& request) const;
|
|
|
+ CreateSimpleOfficeSiteOutcome createSimpleOfficeSite(const Model::CreateSimpleOfficeSiteRequest &request)const;
|
|
|
+ void createSimpleOfficeSiteAsync(const Model::CreateSimpleOfficeSiteRequest& request, const CreateSimpleOfficeSiteAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ CreateSimpleOfficeSiteOutcomeCallable createSimpleOfficeSiteCallable(const Model::CreateSimpleOfficeSiteRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ DeleteDesktopGroupOutcome deleteDesktopGroup(const Model::DeleteDesktopGroupRequest &request)const;
|
|
|
+ void deleteDesktopGroupAsync(const Model::DeleteDesktopGroupRequest& request, const DeleteDesktopGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DeleteDesktopGroupOutcomeCallable deleteDesktopGroupCallable(const Model::DeleteDesktopGroupRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ DeleteNASFileSystemsOutcome deleteNASFileSystems(const Model::DeleteNASFileSystemsRequest &request)const;
|
|
|
+ void deleteNASFileSystemsAsync(const Model::DeleteNASFileSystemsRequest& request, const DeleteNASFileSystemsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DeleteNASFileSystemsOutcomeCallable deleteNASFileSystemsCallable(const Model::DeleteNASFileSystemsRequest& request) const;
|
|
|
+ DeleteNetworkPackagesOutcome deleteNetworkPackages(const Model::DeleteNetworkPackagesRequest &request)const;
|
|
|
+ void deleteNetworkPackagesAsync(const Model::DeleteNetworkPackagesRequest& request, const DeleteNetworkPackagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DeleteNetworkPackagesOutcomeCallable deleteNetworkPackagesCallable(const Model::DeleteNetworkPackagesRequest& request) const;
|
|
|
+ DeleteOfficeSitesOutcome deleteOfficeSites(const Model::DeleteOfficeSitesRequest &request)const;
|
|
|
+ void deleteOfficeSitesAsync(const Model::DeleteOfficeSitesRequest& request, const DeleteOfficeSitesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DeleteOfficeSitesOutcomeCallable deleteOfficeSitesCallable(const Model::DeleteOfficeSitesRequest& request) const;
|
|
|
+ DeletePolicyGroupsOutcome deletePolicyGroups(const Model::DeletePolicyGroupsRequest &request)const;
|
|
|
+ void deletePolicyGroupsAsync(const Model::DeletePolicyGroupsRequest& request, const DeletePolicyGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DeletePolicyGroupsOutcomeCallable deletePolicyGroupsCallable(const Model::DeletePolicyGroupsRequest& request) const;
|
|
|
+ DeleteSnapshotOutcome deleteSnapshot(const Model::DeleteSnapshotRequest &request)const;
|
|
|
+ void deleteSnapshotAsync(const Model::DeleteSnapshotRequest& request, const DeleteSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DeleteSnapshotOutcomeCallable deleteSnapshotCallable(const Model::DeleteSnapshotRequest& request) const;
|
|
|
+ DeleteVirtualMFADeviceOutcome deleteVirtualMFADevice(const Model::DeleteVirtualMFADeviceRequest &request)const;
|
|
|
+ void deleteVirtualMFADeviceAsync(const Model::DeleteVirtualMFADeviceRequest& request, const DeleteVirtualMFADeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DeleteVirtualMFADeviceOutcomeCallable deleteVirtualMFADeviceCallable(const Model::DeleteVirtualMFADeviceRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ DescribeCustomizedListHeadersOutcome describeCustomizedListHeaders(const Model::DescribeCustomizedListHeadersRequest &request)const;
|
|
|
+ void describeCustomizedListHeadersAsync(const Model::DescribeCustomizedListHeadersRequest& request, const DescribeCustomizedListHeadersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeCustomizedListHeadersOutcomeCallable describeCustomizedListHeadersCallable(const Model::DescribeCustomizedListHeadersRequest& request) const;
|
|
|
+ DescribeDesktopGroupsOutcome describeDesktopGroups(const Model::DescribeDesktopGroupsRequest &request)const;
|
|
|
+ void describeDesktopGroupsAsync(const Model::DescribeDesktopGroupsRequest& request, const DescribeDesktopGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeDesktopGroupsOutcomeCallable describeDesktopGroupsCallable(const Model::DescribeDesktopGroupsRequest& request) const;
|
|
|
+ DescribeDesktopIdsByVulNamesOutcome describeDesktopIdsByVulNames(const Model::DescribeDesktopIdsByVulNamesRequest &request)const;
|
|
|
+ void describeDesktopIdsByVulNamesAsync(const Model::DescribeDesktopIdsByVulNamesRequest& request, const DescribeDesktopIdsByVulNamesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeDesktopIdsByVulNamesOutcomeCallable describeDesktopIdsByVulNamesCallable(const Model::DescribeDesktopIdsByVulNamesRequest& request) const;
|
|
|
+ DescribeDesktopTypesOutcome describeDesktopTypes(const Model::DescribeDesktopTypesRequest &request)const;
|
|
|
+ void describeDesktopTypesAsync(const Model::DescribeDesktopTypesRequest& request, const DescribeDesktopTypesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeDesktopTypesOutcomeCallable describeDesktopTypesCallable(const Model::DescribeDesktopTypesRequest& request) const;
|
|
|
+ DescribeDesktopsOutcome describeDesktops(const Model::DescribeDesktopsRequest &request)const;
|
|
|
+ void describeDesktopsAsync(const Model::DescribeDesktopsRequest& request, const DescribeDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeDesktopsOutcomeCallable describeDesktopsCallable(const Model::DescribeDesktopsRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ DescribeFlowStatisticOutcome describeFlowStatistic(const Model::DescribeFlowStatisticRequest &request)const;
|
|
|
+ void describeFlowStatisticAsync(const Model::DescribeFlowStatisticRequest& request, const DescribeFlowStatisticAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeFlowStatisticOutcomeCallable describeFlowStatisticCallable(const Model::DescribeFlowStatisticRequest& request) const;
|
|
|
+ DescribeFotaPendingDesktopsOutcome describeFotaPendingDesktops(const Model::DescribeFotaPendingDesktopsRequest &request)const;
|
|
|
+ void describeFotaPendingDesktopsAsync(const Model::DescribeFotaPendingDesktopsRequest& request, const DescribeFotaPendingDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeFotaPendingDesktopsOutcomeCallable describeFotaPendingDesktopsCallable(const Model::DescribeFotaPendingDesktopsRequest& request) const;
|
|
|
+ DescribeFotaTasksOutcome describeFotaTasks(const Model::DescribeFotaTasksRequest &request)const;
|
|
|
+ void describeFotaTasksAsync(const Model::DescribeFotaTasksRequest& request, const DescribeFotaTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeFotaTasksOutcomeCallable describeFotaTasksCallable(const Model::DescribeFotaTasksRequest& request) const;
|
|
|
+ DescribeFrontVulPatchListOutcome describeFrontVulPatchList(const Model::DescribeFrontVulPatchListRequest &request)const;
|
|
|
+ void describeFrontVulPatchListAsync(const Model::DescribeFrontVulPatchListRequest& request, const DescribeFrontVulPatchListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeFrontVulPatchListOutcomeCallable describeFrontVulPatchListCallable(const Model::DescribeFrontVulPatchListRequest& request) const;
|
|
|
+ DescribeGroupedVulOutcome describeGroupedVul(const Model::DescribeGroupedVulRequest &request)const;
|
|
|
+ void describeGroupedVulAsync(const Model::DescribeGroupedVulRequest& request, const DescribeGroupedVulAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeGroupedVulOutcomeCallable describeGroupedVulCallable(const Model::DescribeGroupedVulRequest& request) const;
|
|
|
+ DescribeImageModifiedRecordsOutcome describeImageModifiedRecords(const Model::DescribeImageModifiedRecordsRequest &request)const;
|
|
|
+ void describeImageModifiedRecordsAsync(const Model::DescribeImageModifiedRecordsRequest& request, const DescribeImageModifiedRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeImageModifiedRecordsOutcomeCallable describeImageModifiedRecordsCallable(const Model::DescribeImageModifiedRecordsRequest& request) const;
|
|
|
+ DescribeImagePermissionOutcome describeImagePermission(const Model::DescribeImagePermissionRequest &request)const;
|
|
|
+ void describeImagePermissionAsync(const Model::DescribeImagePermissionRequest& request, const DescribeImagePermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeImagePermissionOutcomeCallable describeImagePermissionCallable(const Model::DescribeImagePermissionRequest& request) const;
|
|
|
+ DescribeImagesOutcome describeImages(const Model::DescribeImagesRequest &request)const;
|
|
|
+ void describeImagesAsync(const Model::DescribeImagesRequest& request, const DescribeImagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeImagesOutcomeCallable describeImagesCallable(const Model::DescribeImagesRequest& request) const;
|
|
|
+ DescribeInvocationsOutcome describeInvocations(const Model::DescribeInvocationsRequest &request)const;
|
|
|
+ void describeInvocationsAsync(const Model::DescribeInvocationsRequest& request, const DescribeInvocationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeInvocationsOutcomeCallable describeInvocationsCallable(const Model::DescribeInvocationsRequest& request) const;
|
|
|
+ DescribeKmsKeysOutcome describeKmsKeys(const Model::DescribeKmsKeysRequest &request)const;
|
|
|
+ void describeKmsKeysAsync(const Model::DescribeKmsKeysRequest& request, const DescribeKmsKeysAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeKmsKeysOutcomeCallable describeKmsKeysCallable(const Model::DescribeKmsKeysRequest& request) const;
|
|
|
+ DescribeNASFileSystemsOutcome describeNASFileSystems(const Model::DescribeNASFileSystemsRequest &request)const;
|
|
|
+ void describeNASFileSystemsAsync(const Model::DescribeNASFileSystemsRequest& request, const DescribeNASFileSystemsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeNASFileSystemsOutcomeCallable describeNASFileSystemsCallable(const Model::DescribeNASFileSystemsRequest& request) const;
|
|
|
+ DescribeNetworkPackagesOutcome describeNetworkPackages(const Model::DescribeNetworkPackagesRequest &request)const;
|
|
|
+ void describeNetworkPackagesAsync(const Model::DescribeNetworkPackagesRequest& request, const DescribeNetworkPackagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeNetworkPackagesOutcomeCallable describeNetworkPackagesCallable(const Model::DescribeNetworkPackagesRequest& request) const;
|
|
|
+ DescribeOfficeSitesOutcome describeOfficeSites(const Model::DescribeOfficeSitesRequest &request)const;
|
|
|
+ void describeOfficeSitesAsync(const Model::DescribeOfficeSitesRequest& request, const DescribeOfficeSitesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeOfficeSitesOutcomeCallable describeOfficeSitesCallable(const Model::DescribeOfficeSitesRequest& request) const;
|
|
|
+ DescribePolicyGroupsOutcome describePolicyGroups(const Model::DescribePolicyGroupsRequest &request)const;
|
|
|
+ void describePolicyGroupsAsync(const Model::DescribePolicyGroupsRequest& request, const DescribePolicyGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribePolicyGroupsOutcomeCallable describePolicyGroupsCallable(const Model::DescribePolicyGroupsRequest& request) const;
|
|
|
+ DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
|
|
|
+ void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
|
|
|
+ DescribeScanTaskProgressOutcome describeScanTaskProgress(const Model::DescribeScanTaskProgressRequest &request)const;
|
|
|
+ void describeScanTaskProgressAsync(const Model::DescribeScanTaskProgressRequest& request, const DescribeScanTaskProgressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeScanTaskProgressOutcomeCallable describeScanTaskProgressCallable(const Model::DescribeScanTaskProgressRequest& request) const;
|
|
|
+ DescribeSecurityEventOperationStatusOutcome describeSecurityEventOperationStatus(const Model::DescribeSecurityEventOperationStatusRequest &request)const;
|
|
|
+ void describeSecurityEventOperationStatusAsync(const Model::DescribeSecurityEventOperationStatusRequest& request, const DescribeSecurityEventOperationStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeSecurityEventOperationStatusOutcomeCallable describeSecurityEventOperationStatusCallable(const Model::DescribeSecurityEventOperationStatusRequest& request) const;
|
|
|
+ DescribeSecurityEventOperationsOutcome describeSecurityEventOperations(const Model::DescribeSecurityEventOperationsRequest &request)const;
|
|
|
+ void describeSecurityEventOperationsAsync(const Model::DescribeSecurityEventOperationsRequest& request, const DescribeSecurityEventOperationsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeSecurityEventOperationsOutcomeCallable describeSecurityEventOperationsCallable(const Model::DescribeSecurityEventOperationsRequest& request) const;
|
|
|
+ DescribeSnapshotsOutcome describeSnapshots(const Model::DescribeSnapshotsRequest &request)const;
|
|
|
+ void describeSnapshotsAsync(const Model::DescribeSnapshotsRequest& request, const DescribeSnapshotsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeSnapshotsOutcomeCallable describeSnapshotsCallable(const Model::DescribeSnapshotsRequest& request) const;
|
|
|
+ DescribeSuspEventOverviewOutcome describeSuspEventOverview(const Model::DescribeSuspEventOverviewRequest &request)const;
|
|
|
+ void describeSuspEventOverviewAsync(const Model::DescribeSuspEventOverviewRequest& request, const DescribeSuspEventOverviewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeSuspEventOverviewOutcomeCallable describeSuspEventOverviewCallable(const Model::DescribeSuspEventOverviewRequest& request) const;
|
|
|
+ DescribeSuspEventQuaraFilesOutcome describeSuspEventQuaraFiles(const Model::DescribeSuspEventQuaraFilesRequest &request)const;
|
|
|
+ void describeSuspEventQuaraFilesAsync(const Model::DescribeSuspEventQuaraFilesRequest& request, const DescribeSuspEventQuaraFilesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeSuspEventQuaraFilesOutcomeCallable describeSuspEventQuaraFilesCallable(const Model::DescribeSuspEventQuaraFilesRequest& request) const;
|
|
|
+ DescribeSuspEventsOutcome describeSuspEvents(const Model::DescribeSuspEventsRequest &request)const;
|
|
|
+ void describeSuspEventsAsync(const Model::DescribeSuspEventsRequest& request, const DescribeSuspEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeSuspEventsOutcomeCallable describeSuspEventsCallable(const Model::DescribeSuspEventsRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ DescribeUsersPasswordOutcome describeUsersPassword(const Model::DescribeUsersPasswordRequest &request)const;
|
|
|
+ void describeUsersPasswordAsync(const Model::DescribeUsersPasswordRequest& request, const DescribeUsersPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeUsersPasswordOutcomeCallable describeUsersPasswordCallable(const Model::DescribeUsersPasswordRequest& request) const;
|
|
|
+ DescribeVirtualMFADevicesOutcome describeVirtualMFADevices(const Model::DescribeVirtualMFADevicesRequest &request)const;
|
|
|
+ void describeVirtualMFADevicesAsync(const Model::DescribeVirtualMFADevicesRequest& request, const DescribeVirtualMFADevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeVirtualMFADevicesOutcomeCallable describeVirtualMFADevicesCallable(const Model::DescribeVirtualMFADevicesRequest& request) const;
|
|
|
+ DescribeVulDetailsOutcome describeVulDetails(const Model::DescribeVulDetailsRequest &request)const;
|
|
|
+ void describeVulDetailsAsync(const Model::DescribeVulDetailsRequest& request, const DescribeVulDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeVulDetailsOutcomeCallable describeVulDetailsCallable(const Model::DescribeVulDetailsRequest& request) const;
|
|
|
+ DescribeVulListOutcome describeVulList(const Model::DescribeVulListRequest &request)const;
|
|
|
+ void describeVulListAsync(const Model::DescribeVulListRequest& request, const DescribeVulListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeVulListOutcomeCallable describeVulListCallable(const Model::DescribeVulListRequest& request) const;
|
|
|
+ DescribeVulOverviewOutcome describeVulOverview(const Model::DescribeVulOverviewRequest &request)const;
|
|
|
+ void describeVulOverviewAsync(const Model::DescribeVulOverviewRequest& request, const DescribeVulOverviewAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeVulOverviewOutcomeCallable describeVulOverviewCallable(const Model::DescribeVulOverviewRequest& request) const;
|
|
|
+ DescribeZonesOutcome describeZones(const Model::DescribeZonesRequest &request)const;
|
|
|
+ void describeZonesAsync(const Model::DescribeZonesRequest& request, const DescribeZonesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DescribeZonesOutcomeCallable describeZonesCallable(const Model::DescribeZonesRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ DissociateNetworkPackageOutcome dissociateNetworkPackage(const Model::DissociateNetworkPackageRequest &request)const;
|
|
|
+ void dissociateNetworkPackageAsync(const Model::DissociateNetworkPackageRequest& request, const DissociateNetworkPackageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ DissociateNetworkPackageOutcomeCallable dissociateNetworkPackageCallable(const Model::DissociateNetworkPackageRequest& request) const;
|
|
|
+ ExportClientEventsOutcome exportClientEvents(const Model::ExportClientEventsRequest &request)const;
|
|
|
+ void exportClientEventsAsync(const Model::ExportClientEventsRequest& request, const ExportClientEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ExportClientEventsOutcomeCallable exportClientEventsCallable(const Model::ExportClientEventsRequest& request) const;
|
|
|
+ ExportDesktopGroupInfoOutcome exportDesktopGroupInfo(const Model::ExportDesktopGroupInfoRequest &request)const;
|
|
|
+ void exportDesktopGroupInfoAsync(const Model::ExportDesktopGroupInfoRequest& request, const ExportDesktopGroupInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ExportDesktopGroupInfoOutcomeCallable exportDesktopGroupInfoCallable(const Model::ExportDesktopGroupInfoRequest& request) const;
|
|
|
+ ExportDesktopListInfoOutcome exportDesktopListInfo(const Model::ExportDesktopListInfoRequest &request)const;
|
|
|
+ void exportDesktopListInfoAsync(const Model::ExportDesktopListInfoRequest& request, const ExportDesktopListInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ExportDesktopListInfoOutcomeCallable exportDesktopListInfoCallable(const Model::ExportDesktopListInfoRequest& request) const;
|
|
|
+ GetConnectionTicketOutcome getConnectionTicket(const Model::GetConnectionTicketRequest &request)const;
|
|
|
+ void getConnectionTicketAsync(const Model::GetConnectionTicketRequest& request, const GetConnectionTicketAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ GetConnectionTicketOutcomeCallable getConnectionTicketCallable(const Model::GetConnectionTicketRequest& request) const;
|
|
|
+ GetDesktopGroupDetailOutcome getDesktopGroupDetail(const Model::GetDesktopGroupDetailRequest &request)const;
|
|
|
+ void getDesktopGroupDetailAsync(const Model::GetDesktopGroupDetailRequest& request, const GetDesktopGroupDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ GetDesktopGroupDetailOutcomeCallable getDesktopGroupDetailCallable(const Model::GetDesktopGroupDetailRequest& request) const;
|
|
|
+ GetOfficeSiteSsoStatusOutcome getOfficeSiteSsoStatus(const Model::GetOfficeSiteSsoStatusRequest &request)const;
|
|
|
+ void getOfficeSiteSsoStatusAsync(const Model::GetOfficeSiteSsoStatusRequest& request, const GetOfficeSiteSsoStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ GetOfficeSiteSsoStatusOutcomeCallable getOfficeSiteSsoStatusCallable(const Model::GetOfficeSiteSsoStatusRequest& request) const;
|
|
|
+ GetSpMetadataOutcome getSpMetadata(const Model::GetSpMetadataRequest &request)const;
|
|
|
+ void getSpMetadataAsync(const Model::GetSpMetadataRequest& request, const GetSpMetadataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ GetSpMetadataOutcomeCallable getSpMetadataCallable(const Model::GetSpMetadataRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ ListOfficeSiteUsersOutcome listOfficeSiteUsers(const Model::ListOfficeSiteUsersRequest &request)const;
|
|
|
+ void listOfficeSiteUsersAsync(const Model::ListOfficeSiteUsersRequest& request, const ListOfficeSiteUsersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ListOfficeSiteUsersOutcomeCallable listOfficeSiteUsersCallable(const Model::ListOfficeSiteUsersRequest& request) const;
|
|
|
+ ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
|
|
|
+ void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
|
|
|
+ ListUserAdOrganizationUnitsOutcome listUserAdOrganizationUnits(const Model::ListUserAdOrganizationUnitsRequest &request)const;
|
|
|
+ void listUserAdOrganizationUnitsAsync(const Model::ListUserAdOrganizationUnitsRequest& request, const ListUserAdOrganizationUnitsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ListUserAdOrganizationUnitsOutcomeCallable listUserAdOrganizationUnitsCallable(const Model::ListUserAdOrganizationUnitsRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ ModifyCustomizedListHeadersOutcome modifyCustomizedListHeaders(const Model::ModifyCustomizedListHeadersRequest &request)const;
|
|
|
+ void modifyCustomizedListHeadersAsync(const Model::ModifyCustomizedListHeadersRequest& request, const ModifyCustomizedListHeadersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyCustomizedListHeadersOutcomeCallable modifyCustomizedListHeadersCallable(const Model::ModifyCustomizedListHeadersRequest& request) const;
|
|
|
+ ModifyDesktopChargeTypeOutcome modifyDesktopChargeType(const Model::ModifyDesktopChargeTypeRequest &request)const;
|
|
|
+ void modifyDesktopChargeTypeAsync(const Model::ModifyDesktopChargeTypeRequest& request, const ModifyDesktopChargeTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyDesktopChargeTypeOutcomeCallable modifyDesktopChargeTypeCallable(const Model::ModifyDesktopChargeTypeRequest& request) const;
|
|
|
+ ModifyDesktopGroupOutcome modifyDesktopGroup(const Model::ModifyDesktopGroupRequest &request)const;
|
|
|
+ void modifyDesktopGroupAsync(const Model::ModifyDesktopGroupRequest& request, const ModifyDesktopGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyDesktopGroupOutcomeCallable modifyDesktopGroupCallable(const Model::ModifyDesktopGroupRequest& request) const;
|
|
|
+ ModifyDesktopHostNameOutcome modifyDesktopHostName(const Model::ModifyDesktopHostNameRequest &request)const;
|
|
|
+ void modifyDesktopHostNameAsync(const Model::ModifyDesktopHostNameRequest& request, const ModifyDesktopHostNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyDesktopHostNameOutcomeCallable modifyDesktopHostNameCallable(const Model::ModifyDesktopHostNameRequest& request) const;
|
|
|
+ ModifyDesktopNameOutcome modifyDesktopName(const Model::ModifyDesktopNameRequest &request)const;
|
|
|
+ void modifyDesktopNameAsync(const Model::ModifyDesktopNameRequest& request, const ModifyDesktopNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyDesktopNameOutcomeCallable modifyDesktopNameCallable(const Model::ModifyDesktopNameRequest& request) const;
|
|
|
+ ModifyDesktopSpecOutcome modifyDesktopSpec(const Model::ModifyDesktopSpecRequest &request)const;
|
|
|
+ void modifyDesktopSpecAsync(const Model::ModifyDesktopSpecRequest& request, const ModifyDesktopSpecAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyDesktopSpecOutcomeCallable modifyDesktopSpecCallable(const Model::ModifyDesktopSpecRequest& request) const;
|
|
|
+ ModifyDesktopsPolicyGroupOutcome modifyDesktopsPolicyGroup(const Model::ModifyDesktopsPolicyGroupRequest &request)const;
|
|
|
+ void modifyDesktopsPolicyGroupAsync(const Model::ModifyDesktopsPolicyGroupRequest& request, const ModifyDesktopsPolicyGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyDesktopsPolicyGroupOutcomeCallable modifyDesktopsPolicyGroupCallable(const Model::ModifyDesktopsPolicyGroupRequest& request) const;
|
|
|
+ ModifyDiskSpecOutcome modifyDiskSpec(const Model::ModifyDiskSpecRequest &request)const;
|
|
|
+ void modifyDiskSpecAsync(const Model::ModifyDiskSpecRequest& request, const ModifyDiskSpecAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyDiskSpecOutcomeCallable modifyDiskSpecCallable(const Model::ModifyDiskSpecRequest& request) const;
|
|
|
+ ModifyEntitlementOutcome modifyEntitlement(const Model::ModifyEntitlementRequest &request)const;
|
|
|
+ void modifyEntitlementAsync(const Model::ModifyEntitlementRequest& request, const ModifyEntitlementAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyEntitlementOutcomeCallable modifyEntitlementCallable(const Model::ModifyEntitlementRequest& request) const;
|
|
|
+ ModifyImageAttributeOutcome modifyImageAttribute(const Model::ModifyImageAttributeRequest &request)const;
|
|
|
+ void modifyImageAttributeAsync(const Model::ModifyImageAttributeRequest& request, const ModifyImageAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyImageAttributeOutcomeCallable modifyImageAttributeCallable(const Model::ModifyImageAttributeRequest& request) const;
|
|
|
+ ModifyImagePermissionOutcome modifyImagePermission(const Model::ModifyImagePermissionRequest &request)const;
|
|
|
+ void modifyImagePermissionAsync(const Model::ModifyImagePermissionRequest& request, const ModifyImagePermissionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyImagePermissionOutcomeCallable modifyImagePermissionCallable(const Model::ModifyImagePermissionRequest& request) const;
|
|
|
+ ModifyNASDefaultMountTargetOutcome modifyNASDefaultMountTarget(const Model::ModifyNASDefaultMountTargetRequest &request)const;
|
|
|
+ void modifyNASDefaultMountTargetAsync(const Model::ModifyNASDefaultMountTargetRequest& request, const ModifyNASDefaultMountTargetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyNASDefaultMountTargetOutcomeCallable modifyNASDefaultMountTargetCallable(const Model::ModifyNASDefaultMountTargetRequest& request) const;
|
|
|
+ ModifyNetworkPackageBandwidthOutcome modifyNetworkPackageBandwidth(const Model::ModifyNetworkPackageBandwidthRequest &request)const;
|
|
|
+ void modifyNetworkPackageBandwidthAsync(const Model::ModifyNetworkPackageBandwidthRequest& request, const ModifyNetworkPackageBandwidthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyNetworkPackageBandwidthOutcomeCallable modifyNetworkPackageBandwidthCallable(const Model::ModifyNetworkPackageBandwidthRequest& request) const;
|
|
|
+ ModifyNetworkPackageEnabledOutcome modifyNetworkPackageEnabled(const Model::ModifyNetworkPackageEnabledRequest &request)const;
|
|
|
+ void modifyNetworkPackageEnabledAsync(const Model::ModifyNetworkPackageEnabledRequest& request, const ModifyNetworkPackageEnabledAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyNetworkPackageEnabledOutcomeCallable modifyNetworkPackageEnabledCallable(const Model::ModifyNetworkPackageEnabledRequest& request) const;
|
|
|
+ ModifyOfficeSiteAttributeOutcome modifyOfficeSiteAttribute(const Model::ModifyOfficeSiteAttributeRequest &request)const;
|
|
|
+ void modifyOfficeSiteAttributeAsync(const Model::ModifyOfficeSiteAttributeRequest& request, const ModifyOfficeSiteAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyOfficeSiteAttributeOutcomeCallable modifyOfficeSiteAttributeCallable(const Model::ModifyOfficeSiteAttributeRequest& request) const;
|
|
|
+ ModifyOfficeSiteCrossDesktopAccessOutcome modifyOfficeSiteCrossDesktopAccess(const Model::ModifyOfficeSiteCrossDesktopAccessRequest &request)const;
|
|
|
+ void modifyOfficeSiteCrossDesktopAccessAsync(const Model::ModifyOfficeSiteCrossDesktopAccessRequest& request, const ModifyOfficeSiteCrossDesktopAccessAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyOfficeSiteCrossDesktopAccessOutcomeCallable modifyOfficeSiteCrossDesktopAccessCallable(const Model::ModifyOfficeSiteCrossDesktopAccessRequest& request) const;
|
|
|
+ ModifyOfficeSiteMfaEnabledOutcome modifyOfficeSiteMfaEnabled(const Model::ModifyOfficeSiteMfaEnabledRequest &request)const;
|
|
|
+ void modifyOfficeSiteMfaEnabledAsync(const Model::ModifyOfficeSiteMfaEnabledRequest& request, const ModifyOfficeSiteMfaEnabledAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyOfficeSiteMfaEnabledOutcomeCallable modifyOfficeSiteMfaEnabledCallable(const Model::ModifyOfficeSiteMfaEnabledRequest& request) const;
|
|
|
+ ModifyOperateVulOutcome modifyOperateVul(const Model::ModifyOperateVulRequest &request)const;
|
|
|
+ void modifyOperateVulAsync(const Model::ModifyOperateVulRequest& request, const ModifyOperateVulAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyOperateVulOutcomeCallable modifyOperateVulCallable(const Model::ModifyOperateVulRequest& request) const;
|
|
|
+ ModifyPolicyGroupOutcome modifyPolicyGroup(const Model::ModifyPolicyGroupRequest &request)const;
|
|
|
+ void modifyPolicyGroupAsync(const Model::ModifyPolicyGroupRequest& request, const ModifyPolicyGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyPolicyGroupOutcomeCallable modifyPolicyGroupCallable(const Model::ModifyPolicyGroupRequest& request) const;
|
|
|
+ ModifyUserEntitlementOutcome modifyUserEntitlement(const Model::ModifyUserEntitlementRequest &request)const;
|
|
|
+ void modifyUserEntitlementAsync(const Model::ModifyUserEntitlementRequest& request, const ModifyUserEntitlementAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ModifyUserEntitlementOutcomeCallable modifyUserEntitlementCallable(const Model::ModifyUserEntitlementRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ RebootDesktopsOutcome rebootDesktops(const Model::RebootDesktopsRequest &request)const;
|
|
|
+ void rebootDesktopsAsync(const Model::RebootDesktopsRequest& request, const RebootDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ RebootDesktopsOutcomeCallable rebootDesktopsCallable(const Model::RebootDesktopsRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ RenewDesktopsOutcome renewDesktops(const Model::RenewDesktopsRequest &request)const;
|
|
|
+ void renewDesktopsAsync(const Model::RenewDesktopsRequest& request, const RenewDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ RenewDesktopsOutcomeCallable renewDesktopsCallable(const Model::RenewDesktopsRequest& request) const;
|
|
|
+ RenewNetworkPackagesOutcome renewNetworkPackages(const Model::RenewNetworkPackagesRequest &request)const;
|
|
|
+ void renewNetworkPackagesAsync(const Model::RenewNetworkPackagesRequest& request, const RenewNetworkPackagesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ RenewNetworkPackagesOutcomeCallable renewNetworkPackagesCallable(const Model::RenewNetworkPackagesRequest& request) const;
|
|
|
+ ResetDesktopsOutcome resetDesktops(const Model::ResetDesktopsRequest &request)const;
|
|
|
+ void resetDesktopsAsync(const Model::ResetDesktopsRequest& request, const ResetDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ResetDesktopsOutcomeCallable resetDesktopsCallable(const Model::ResetDesktopsRequest& request) const;
|
|
|
+ ResetNASDefaultMountTargetOutcome resetNASDefaultMountTarget(const Model::ResetNASDefaultMountTargetRequest &request)const;
|
|
|
+ void resetNASDefaultMountTargetAsync(const Model::ResetNASDefaultMountTargetRequest& request, const ResetNASDefaultMountTargetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ResetNASDefaultMountTargetOutcomeCallable resetNASDefaultMountTargetCallable(const Model::ResetNASDefaultMountTargetRequest& request) const;
|
|
|
+ ResetSnapshotOutcome resetSnapshot(const Model::ResetSnapshotRequest &request)const;
|
|
|
+ void resetSnapshotAsync(const Model::ResetSnapshotRequest& request, const ResetSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ ResetSnapshotOutcomeCallable resetSnapshotCallable(const Model::ResetSnapshotRequest& request) const;
|
|
|
+ RevokeCoordinatePrivilegeOutcome revokeCoordinatePrivilege(const Model::RevokeCoordinatePrivilegeRequest &request)const;
|
|
|
+ void revokeCoordinatePrivilegeAsync(const Model::RevokeCoordinatePrivilegeRequest& request, const RevokeCoordinatePrivilegeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ RevokeCoordinatePrivilegeOutcomeCallable revokeCoordinatePrivilegeCallable(const Model::RevokeCoordinatePrivilegeRequest& request) const;
|
|
|
+ RollbackSuspEventQuaraFileOutcome rollbackSuspEventQuaraFile(const Model::RollbackSuspEventQuaraFileRequest &request)const;
|
|
|
+ void rollbackSuspEventQuaraFileAsync(const Model::RollbackSuspEventQuaraFileRequest& request, const RollbackSuspEventQuaraFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ RollbackSuspEventQuaraFileOutcomeCallable rollbackSuspEventQuaraFileCallable(const Model::RollbackSuspEventQuaraFileRequest& request) const;
|
|
|
+ RunCommandOutcome runCommand(const Model::RunCommandRequest &request)const;
|
|
|
+ void runCommandAsync(const Model::RunCommandRequest& request, const RunCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ RunCommandOutcomeCallable runCommandCallable(const Model::RunCommandRequest& request) const;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ 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;
|
|
|
+ StartVirusScanTaskOutcome startVirusScanTask(const Model::StartVirusScanTaskRequest &request)const;
|
|
|
+ void startVirusScanTaskAsync(const Model::StartVirusScanTaskRequest& request, const StartVirusScanTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ StartVirusScanTaskOutcomeCallable startVirusScanTaskCallable(const Model::StartVirusScanTaskRequest& request) const;
|
|
|
+ StopDesktopsOutcome stopDesktops(const Model::StopDesktopsRequest &request)const;
|
|
|
+ void stopDesktopsAsync(const Model::StopDesktopsRequest& request, const StopDesktopsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ StopDesktopsOutcomeCallable stopDesktopsCallable(const Model::StopDesktopsRequest& request) const;
|
|
|
+ StopInvocationOutcome stopInvocation(const Model::StopInvocationRequest &request)const;
|
|
|
+ void stopInvocationAsync(const Model::StopInvocationRequest& request, const StopInvocationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ StopInvocationOutcomeCallable stopInvocationCallable(const Model::StopInvocationRequest& request) const;
|
|
|
+ TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
|
|
|
+ void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
|
|
|
+ UnlockVirtualMFADeviceOutcome unlockVirtualMFADevice(const Model::UnlockVirtualMFADeviceRequest &request)const;
|
|
|
+ void unlockVirtualMFADeviceAsync(const Model::UnlockVirtualMFADeviceRequest& request, const UnlockVirtualMFADeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ UnlockVirtualMFADeviceOutcomeCallable unlockVirtualMFADeviceCallable(const Model::UnlockVirtualMFADeviceRequest& request) const;
|
|
|
+ UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const;
|
|
|
+ void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& request) const;
|
|
|
+ UpdateFotaTaskOutcome updateFotaTask(const Model::UpdateFotaTaskRequest &request)const;
|
|
|
+ void updateFotaTaskAsync(const Model::UpdateFotaTaskRequest& request, const UpdateFotaTaskAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ UpdateFotaTaskOutcomeCallable updateFotaTaskCallable(const Model::UpdateFotaTaskRequest& request) const;
|
|
|
+ UploadImageOutcome uploadImage(const Model::UploadImageRequest &request)const;
|
|
|
+ void uploadImageAsync(const Model::UploadImageRequest& request, const UploadImageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
|
|
|
+ UploadImageOutcomeCallable uploadImageCallable(const Model::UploadImageRequest& request) const;
|
|
|
+ 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;
|
|
|
+
|
|
|
+ private:
|
|
|
+ std::shared_ptr<EndpointProvider> endpointProvider_;
|
|
|
+ };
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#endif // !ALIBABACLOUD_ECD_ECDCLIENT_H_
|
sdk-team