Generated 2018-12-12 for vs.

This commit is contained in:
sdk-team
2020-09-22 01:54:19 +00:00
parent 7097cf0d88
commit 2123976cc2
477 changed files with 40745 additions and 0 deletions

View File

@@ -1,3 +1,6 @@
2020-09-22 Version: patch
- Generated 2018-12-12 for `vs`.
2020-09-22 Version: patch
- Generated 2016-11-01 for `live`.

554
vs/CMakeLists.txt Normal file
View File

@@ -0,0 +1,554 @@
#
# Copyright 2009-2017 Alibaba Cloud All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
set(vs_public_header
include/alibabacloud/vs/VsClient.h
include/alibabacloud/vs/VsExport.h )
set(vs_public_header_model
include/alibabacloud/vs/model/AddVsPullStreamInfoConfigRequest.h
include/alibabacloud/vs/model/AddVsPullStreamInfoConfigResult.h
include/alibabacloud/vs/model/BatchBindDirectoriesRequest.h
include/alibabacloud/vs/model/BatchBindDirectoriesResult.h
include/alibabacloud/vs/model/BatchBindParentPlatformDevicesRequest.h
include/alibabacloud/vs/model/BatchBindParentPlatformDevicesResult.h
include/alibabacloud/vs/model/BatchBindPurchasedDevicesRequest.h
include/alibabacloud/vs/model/BatchBindPurchasedDevicesResult.h
include/alibabacloud/vs/model/BatchBindTemplateRequest.h
include/alibabacloud/vs/model/BatchBindTemplateResult.h
include/alibabacloud/vs/model/BatchBindTemplatesRequest.h
include/alibabacloud/vs/model/BatchBindTemplatesResult.h
include/alibabacloud/vs/model/BatchDeleteDevicesRequest.h
include/alibabacloud/vs/model/BatchDeleteDevicesResult.h
include/alibabacloud/vs/model/BatchDeleteVsDomainConfigsRequest.h
include/alibabacloud/vs/model/BatchDeleteVsDomainConfigsResult.h
include/alibabacloud/vs/model/BatchForbidVsStreamRequest.h
include/alibabacloud/vs/model/BatchForbidVsStreamResult.h
include/alibabacloud/vs/model/BatchResumeVsStreamRequest.h
include/alibabacloud/vs/model/BatchResumeVsStreamResult.h
include/alibabacloud/vs/model/BatchSetVsDomainConfigsRequest.h
include/alibabacloud/vs/model/BatchSetVsDomainConfigsResult.h
include/alibabacloud/vs/model/BatchStartDevicesRequest.h
include/alibabacloud/vs/model/BatchStartDevicesResult.h
include/alibabacloud/vs/model/BatchStartStreamsRequest.h
include/alibabacloud/vs/model/BatchStartStreamsResult.h
include/alibabacloud/vs/model/BatchStopDevicesRequest.h
include/alibabacloud/vs/model/BatchStopDevicesResult.h
include/alibabacloud/vs/model/BatchStopStreamsRequest.h
include/alibabacloud/vs/model/BatchStopStreamsResult.h
include/alibabacloud/vs/model/BatchUnbindDirectoriesRequest.h
include/alibabacloud/vs/model/BatchUnbindDirectoriesResult.h
include/alibabacloud/vs/model/BatchUnbindParentPlatformDevicesRequest.h
include/alibabacloud/vs/model/BatchUnbindParentPlatformDevicesResult.h
include/alibabacloud/vs/model/BatchUnbindPurchasedDevicesRequest.h
include/alibabacloud/vs/model/BatchUnbindPurchasedDevicesResult.h
include/alibabacloud/vs/model/BatchUnbindTemplateRequest.h
include/alibabacloud/vs/model/BatchUnbindTemplateResult.h
include/alibabacloud/vs/model/BatchUnbindTemplatesRequest.h
include/alibabacloud/vs/model/BatchUnbindTemplatesResult.h
include/alibabacloud/vs/model/BindDirectoryRequest.h
include/alibabacloud/vs/model/BindDirectoryResult.h
include/alibabacloud/vs/model/BindParentPlatformDeviceRequest.h
include/alibabacloud/vs/model/BindParentPlatformDeviceResult.h
include/alibabacloud/vs/model/BindPurchasedDeviceRequest.h
include/alibabacloud/vs/model/BindPurchasedDeviceResult.h
include/alibabacloud/vs/model/BindTemplateRequest.h
include/alibabacloud/vs/model/BindTemplateResult.h
include/alibabacloud/vs/model/ContinuousAdjustRequest.h
include/alibabacloud/vs/model/ContinuousAdjustResult.h
include/alibabacloud/vs/model/ContinuousMoveRequest.h
include/alibabacloud/vs/model/ContinuousMoveResult.h
include/alibabacloud/vs/model/CreateDeviceRequest.h
include/alibabacloud/vs/model/CreateDeviceResult.h
include/alibabacloud/vs/model/CreateDeviceAlarmRequest.h
include/alibabacloud/vs/model/CreateDeviceAlarmResult.h
include/alibabacloud/vs/model/CreateDirectoryRequest.h
include/alibabacloud/vs/model/CreateDirectoryResult.h
include/alibabacloud/vs/model/CreateGroupRequest.h
include/alibabacloud/vs/model/CreateGroupResult.h
include/alibabacloud/vs/model/CreateParentPlatformRequest.h
include/alibabacloud/vs/model/CreateParentPlatformResult.h
include/alibabacloud/vs/model/CreateStreamSnapshotRequest.h
include/alibabacloud/vs/model/CreateStreamSnapshotResult.h
include/alibabacloud/vs/model/CreateTemplateRequest.h
include/alibabacloud/vs/model/CreateTemplateResult.h
include/alibabacloud/vs/model/DeleteDeviceRequest.h
include/alibabacloud/vs/model/DeleteDeviceResult.h
include/alibabacloud/vs/model/DeleteDirectoryRequest.h
include/alibabacloud/vs/model/DeleteDirectoryResult.h
include/alibabacloud/vs/model/DeleteGroupRequest.h
include/alibabacloud/vs/model/DeleteGroupResult.h
include/alibabacloud/vs/model/DeleteParentPlatformRequest.h
include/alibabacloud/vs/model/DeleteParentPlatformResult.h
include/alibabacloud/vs/model/DeletePresetRequest.h
include/alibabacloud/vs/model/DeletePresetResult.h
include/alibabacloud/vs/model/DeleteTemplateRequest.h
include/alibabacloud/vs/model/DeleteTemplateResult.h
include/alibabacloud/vs/model/DeleteVsPullStreamInfoConfigRequest.h
include/alibabacloud/vs/model/DeleteVsPullStreamInfoConfigResult.h
include/alibabacloud/vs/model/DeleteVsStreamsNotifyUrlConfigRequest.h
include/alibabacloud/vs/model/DeleteVsStreamsNotifyUrlConfigResult.h
include/alibabacloud/vs/model/DescribeAccountStatRequest.h
include/alibabacloud/vs/model/DescribeAccountStatResult.h
include/alibabacloud/vs/model/DescribeDeviceRequest.h
include/alibabacloud/vs/model/DescribeDeviceResult.h
include/alibabacloud/vs/model/DescribeDeviceChannelsRequest.h
include/alibabacloud/vs/model/DescribeDeviceChannelsResult.h
include/alibabacloud/vs/model/DescribeDeviceGatewayRequest.h
include/alibabacloud/vs/model/DescribeDeviceGatewayResult.h
include/alibabacloud/vs/model/DescribeDeviceURLRequest.h
include/alibabacloud/vs/model/DescribeDeviceURLResult.h
include/alibabacloud/vs/model/DescribeDevicesRequest.h
include/alibabacloud/vs/model/DescribeDevicesResult.h
include/alibabacloud/vs/model/DescribeDirectoriesRequest.h
include/alibabacloud/vs/model/DescribeDirectoriesResult.h
include/alibabacloud/vs/model/DescribeDirectoryRequest.h
include/alibabacloud/vs/model/DescribeDirectoryResult.h
include/alibabacloud/vs/model/DescribeGroupRequest.h
include/alibabacloud/vs/model/DescribeGroupResult.h
include/alibabacloud/vs/model/DescribeGroupsRequest.h
include/alibabacloud/vs/model/DescribeGroupsResult.h
include/alibabacloud/vs/model/DescribeParentPlatformRequest.h
include/alibabacloud/vs/model/DescribeParentPlatformResult.h
include/alibabacloud/vs/model/DescribeParentPlatformDevicesRequest.h
include/alibabacloud/vs/model/DescribeParentPlatformDevicesResult.h
include/alibabacloud/vs/model/DescribeParentPlatformsRequest.h
include/alibabacloud/vs/model/DescribeParentPlatformsResult.h
include/alibabacloud/vs/model/DescribePresetsRequest.h
include/alibabacloud/vs/model/DescribePresetsResult.h
include/alibabacloud/vs/model/DescribePurchasedDeviceRequest.h
include/alibabacloud/vs/model/DescribePurchasedDeviceResult.h
include/alibabacloud/vs/model/DescribePurchasedDevicesRequest.h
include/alibabacloud/vs/model/DescribePurchasedDevicesResult.h
include/alibabacloud/vs/model/DescribeRecordsRequest.h
include/alibabacloud/vs/model/DescribeRecordsResult.h
include/alibabacloud/vs/model/DescribeStreamRequest.h
include/alibabacloud/vs/model/DescribeStreamResult.h
include/alibabacloud/vs/model/DescribeStreamURLRequest.h
include/alibabacloud/vs/model/DescribeStreamURLResult.h
include/alibabacloud/vs/model/DescribeStreamVodListRequest.h
include/alibabacloud/vs/model/DescribeStreamVodListResult.h
include/alibabacloud/vs/model/DescribeStreamsRequest.h
include/alibabacloud/vs/model/DescribeStreamsResult.h
include/alibabacloud/vs/model/DescribeTemplateRequest.h
include/alibabacloud/vs/model/DescribeTemplateResult.h
include/alibabacloud/vs/model/DescribeTemplatesRequest.h
include/alibabacloud/vs/model/DescribeTemplatesResult.h
include/alibabacloud/vs/model/DescribeVodStreamURLRequest.h
include/alibabacloud/vs/model/DescribeVodStreamURLResult.h
include/alibabacloud/vs/model/DescribeVsCertificateDetailRequest.h
include/alibabacloud/vs/model/DescribeVsCertificateDetailResult.h
include/alibabacloud/vs/model/DescribeVsCertificateListRequest.h
include/alibabacloud/vs/model/DescribeVsCertificateListResult.h
include/alibabacloud/vs/model/DescribeVsDomainBpsDataRequest.h
include/alibabacloud/vs/model/DescribeVsDomainBpsDataResult.h
include/alibabacloud/vs/model/DescribeVsDomainCertificateInfoRequest.h
include/alibabacloud/vs/model/DescribeVsDomainCertificateInfoResult.h
include/alibabacloud/vs/model/DescribeVsDomainConfigsRequest.h
include/alibabacloud/vs/model/DescribeVsDomainConfigsResult.h
include/alibabacloud/vs/model/DescribeVsDomainDetailRequest.h
include/alibabacloud/vs/model/DescribeVsDomainDetailResult.h
include/alibabacloud/vs/model/DescribeVsDomainPvDataRequest.h
include/alibabacloud/vs/model/DescribeVsDomainPvDataResult.h
include/alibabacloud/vs/model/DescribeVsDomainRecordDataRequest.h
include/alibabacloud/vs/model/DescribeVsDomainRecordDataResult.h
include/alibabacloud/vs/model/DescribeVsDomainRegionDataRequest.h
include/alibabacloud/vs/model/DescribeVsDomainRegionDataResult.h
include/alibabacloud/vs/model/DescribeVsDomainReqBpsDataRequest.h
include/alibabacloud/vs/model/DescribeVsDomainReqBpsDataResult.h
include/alibabacloud/vs/model/DescribeVsDomainReqTrafficDataRequest.h
include/alibabacloud/vs/model/DescribeVsDomainReqTrafficDataResult.h
include/alibabacloud/vs/model/DescribeVsDomainSnapshotDataRequest.h
include/alibabacloud/vs/model/DescribeVsDomainSnapshotDataResult.h
include/alibabacloud/vs/model/DescribeVsDomainTrafficDataRequest.h
include/alibabacloud/vs/model/DescribeVsDomainTrafficDataResult.h
include/alibabacloud/vs/model/DescribeVsDomainUvDataRequest.h
include/alibabacloud/vs/model/DescribeVsDomainUvDataResult.h
include/alibabacloud/vs/model/DescribeVsPullStreamInfoConfigRequest.h
include/alibabacloud/vs/model/DescribeVsPullStreamInfoConfigResult.h
include/alibabacloud/vs/model/DescribeVsStreamsNotifyUrlConfigRequest.h
include/alibabacloud/vs/model/DescribeVsStreamsNotifyUrlConfigResult.h
include/alibabacloud/vs/model/DescribeVsStreamsOnlineListRequest.h
include/alibabacloud/vs/model/DescribeVsStreamsOnlineListResult.h
include/alibabacloud/vs/model/DescribeVsStreamsPublishListRequest.h
include/alibabacloud/vs/model/DescribeVsStreamsPublishListResult.h
include/alibabacloud/vs/model/DescribeVsTopDomainsByFlowRequest.h
include/alibabacloud/vs/model/DescribeVsTopDomainsByFlowResult.h
include/alibabacloud/vs/model/DescribeVsUpPeakPublishStreamDataRequest.h
include/alibabacloud/vs/model/DescribeVsUpPeakPublishStreamDataResult.h
include/alibabacloud/vs/model/DescribeVsUserResourcePackageRequest.h
include/alibabacloud/vs/model/DescribeVsUserResourcePackageResult.h
include/alibabacloud/vs/model/ForbidVsStreamRequest.h
include/alibabacloud/vs/model/ForbidVsStreamResult.h
include/alibabacloud/vs/model/GotoPresetRequest.h
include/alibabacloud/vs/model/GotoPresetResult.h
include/alibabacloud/vs/model/ModifyDeviceRequest.h
include/alibabacloud/vs/model/ModifyDeviceResult.h
include/alibabacloud/vs/model/ModifyDeviceAlarmRequest.h
include/alibabacloud/vs/model/ModifyDeviceAlarmResult.h
include/alibabacloud/vs/model/ModifyDeviceCaptureRequest.h
include/alibabacloud/vs/model/ModifyDeviceCaptureResult.h
include/alibabacloud/vs/model/ModifyDeviceChannelsRequest.h
include/alibabacloud/vs/model/ModifyDeviceChannelsResult.h
include/alibabacloud/vs/model/ModifyDirectoryRequest.h
include/alibabacloud/vs/model/ModifyDirectoryResult.h
include/alibabacloud/vs/model/ModifyGroupRequest.h
include/alibabacloud/vs/model/ModifyGroupResult.h
include/alibabacloud/vs/model/ModifyParentPlatformRequest.h
include/alibabacloud/vs/model/ModifyParentPlatformResult.h
include/alibabacloud/vs/model/ModifyTemplateRequest.h
include/alibabacloud/vs/model/ModifyTemplateResult.h
include/alibabacloud/vs/model/ResumeVsStreamRequest.h
include/alibabacloud/vs/model/ResumeVsStreamResult.h
include/alibabacloud/vs/model/SetPresetRequest.h
include/alibabacloud/vs/model/SetPresetResult.h
include/alibabacloud/vs/model/SetVsDomainCertificateRequest.h
include/alibabacloud/vs/model/SetVsDomainCertificateResult.h
include/alibabacloud/vs/model/SetVsStreamsNotifyUrlConfigRequest.h
include/alibabacloud/vs/model/SetVsStreamsNotifyUrlConfigResult.h
include/alibabacloud/vs/model/StartDeviceRequest.h
include/alibabacloud/vs/model/StartDeviceResult.h
include/alibabacloud/vs/model/StartParentPlatformRequest.h
include/alibabacloud/vs/model/StartParentPlatformResult.h
include/alibabacloud/vs/model/StartRecordStreamRequest.h
include/alibabacloud/vs/model/StartRecordStreamResult.h
include/alibabacloud/vs/model/StartStreamRequest.h
include/alibabacloud/vs/model/StartStreamResult.h
include/alibabacloud/vs/model/StartTransferStreamRequest.h
include/alibabacloud/vs/model/StartTransferStreamResult.h
include/alibabacloud/vs/model/StopAdjustRequest.h
include/alibabacloud/vs/model/StopAdjustResult.h
include/alibabacloud/vs/model/StopDeviceRequest.h
include/alibabacloud/vs/model/StopDeviceResult.h
include/alibabacloud/vs/model/StopMoveRequest.h
include/alibabacloud/vs/model/StopMoveResult.h
include/alibabacloud/vs/model/StopRecordStreamRequest.h
include/alibabacloud/vs/model/StopRecordStreamResult.h
include/alibabacloud/vs/model/StopStreamRequest.h
include/alibabacloud/vs/model/StopStreamResult.h
include/alibabacloud/vs/model/StopTransferStreamRequest.h
include/alibabacloud/vs/model/StopTransferStreamResult.h
include/alibabacloud/vs/model/SyncCatalogsRequest.h
include/alibabacloud/vs/model/SyncCatalogsResult.h
include/alibabacloud/vs/model/UnbindDirectoryRequest.h
include/alibabacloud/vs/model/UnbindDirectoryResult.h
include/alibabacloud/vs/model/UnbindParentPlatformDeviceRequest.h
include/alibabacloud/vs/model/UnbindParentPlatformDeviceResult.h
include/alibabacloud/vs/model/UnbindPurchasedDeviceRequest.h
include/alibabacloud/vs/model/UnbindPurchasedDeviceResult.h
include/alibabacloud/vs/model/UnbindTemplateRequest.h
include/alibabacloud/vs/model/UnbindTemplateResult.h
include/alibabacloud/vs/model/UnlockDeviceRequest.h
include/alibabacloud/vs/model/UnlockDeviceResult.h
include/alibabacloud/vs/model/UpdateVsPullStreamInfoConfigRequest.h
include/alibabacloud/vs/model/UpdateVsPullStreamInfoConfigResult.h )
set(vs_src
src/VsClient.cc
src/model/AddVsPullStreamInfoConfigRequest.cc
src/model/AddVsPullStreamInfoConfigResult.cc
src/model/BatchBindDirectoriesRequest.cc
src/model/BatchBindDirectoriesResult.cc
src/model/BatchBindParentPlatformDevicesRequest.cc
src/model/BatchBindParentPlatformDevicesResult.cc
src/model/BatchBindPurchasedDevicesRequest.cc
src/model/BatchBindPurchasedDevicesResult.cc
src/model/BatchBindTemplateRequest.cc
src/model/BatchBindTemplateResult.cc
src/model/BatchBindTemplatesRequest.cc
src/model/BatchBindTemplatesResult.cc
src/model/BatchDeleteDevicesRequest.cc
src/model/BatchDeleteDevicesResult.cc
src/model/BatchDeleteVsDomainConfigsRequest.cc
src/model/BatchDeleteVsDomainConfigsResult.cc
src/model/BatchForbidVsStreamRequest.cc
src/model/BatchForbidVsStreamResult.cc
src/model/BatchResumeVsStreamRequest.cc
src/model/BatchResumeVsStreamResult.cc
src/model/BatchSetVsDomainConfigsRequest.cc
src/model/BatchSetVsDomainConfigsResult.cc
src/model/BatchStartDevicesRequest.cc
src/model/BatchStartDevicesResult.cc
src/model/BatchStartStreamsRequest.cc
src/model/BatchStartStreamsResult.cc
src/model/BatchStopDevicesRequest.cc
src/model/BatchStopDevicesResult.cc
src/model/BatchStopStreamsRequest.cc
src/model/BatchStopStreamsResult.cc
src/model/BatchUnbindDirectoriesRequest.cc
src/model/BatchUnbindDirectoriesResult.cc
src/model/BatchUnbindParentPlatformDevicesRequest.cc
src/model/BatchUnbindParentPlatformDevicesResult.cc
src/model/BatchUnbindPurchasedDevicesRequest.cc
src/model/BatchUnbindPurchasedDevicesResult.cc
src/model/BatchUnbindTemplateRequest.cc
src/model/BatchUnbindTemplateResult.cc
src/model/BatchUnbindTemplatesRequest.cc
src/model/BatchUnbindTemplatesResult.cc
src/model/BindDirectoryRequest.cc
src/model/BindDirectoryResult.cc
src/model/BindParentPlatformDeviceRequest.cc
src/model/BindParentPlatformDeviceResult.cc
src/model/BindPurchasedDeviceRequest.cc
src/model/BindPurchasedDeviceResult.cc
src/model/BindTemplateRequest.cc
src/model/BindTemplateResult.cc
src/model/ContinuousAdjustRequest.cc
src/model/ContinuousAdjustResult.cc
src/model/ContinuousMoveRequest.cc
src/model/ContinuousMoveResult.cc
src/model/CreateDeviceRequest.cc
src/model/CreateDeviceResult.cc
src/model/CreateDeviceAlarmRequest.cc
src/model/CreateDeviceAlarmResult.cc
src/model/CreateDirectoryRequest.cc
src/model/CreateDirectoryResult.cc
src/model/CreateGroupRequest.cc
src/model/CreateGroupResult.cc
src/model/CreateParentPlatformRequest.cc
src/model/CreateParentPlatformResult.cc
src/model/CreateStreamSnapshotRequest.cc
src/model/CreateStreamSnapshotResult.cc
src/model/CreateTemplateRequest.cc
src/model/CreateTemplateResult.cc
src/model/DeleteDeviceRequest.cc
src/model/DeleteDeviceResult.cc
src/model/DeleteDirectoryRequest.cc
src/model/DeleteDirectoryResult.cc
src/model/DeleteGroupRequest.cc
src/model/DeleteGroupResult.cc
src/model/DeleteParentPlatformRequest.cc
src/model/DeleteParentPlatformResult.cc
src/model/DeletePresetRequest.cc
src/model/DeletePresetResult.cc
src/model/DeleteTemplateRequest.cc
src/model/DeleteTemplateResult.cc
src/model/DeleteVsPullStreamInfoConfigRequest.cc
src/model/DeleteVsPullStreamInfoConfigResult.cc
src/model/DeleteVsStreamsNotifyUrlConfigRequest.cc
src/model/DeleteVsStreamsNotifyUrlConfigResult.cc
src/model/DescribeAccountStatRequest.cc
src/model/DescribeAccountStatResult.cc
src/model/DescribeDeviceRequest.cc
src/model/DescribeDeviceResult.cc
src/model/DescribeDeviceChannelsRequest.cc
src/model/DescribeDeviceChannelsResult.cc
src/model/DescribeDeviceGatewayRequest.cc
src/model/DescribeDeviceGatewayResult.cc
src/model/DescribeDeviceURLRequest.cc
src/model/DescribeDeviceURLResult.cc
src/model/DescribeDevicesRequest.cc
src/model/DescribeDevicesResult.cc
src/model/DescribeDirectoriesRequest.cc
src/model/DescribeDirectoriesResult.cc
src/model/DescribeDirectoryRequest.cc
src/model/DescribeDirectoryResult.cc
src/model/DescribeGroupRequest.cc
src/model/DescribeGroupResult.cc
src/model/DescribeGroupsRequest.cc
src/model/DescribeGroupsResult.cc
src/model/DescribeParentPlatformRequest.cc
src/model/DescribeParentPlatformResult.cc
src/model/DescribeParentPlatformDevicesRequest.cc
src/model/DescribeParentPlatformDevicesResult.cc
src/model/DescribeParentPlatformsRequest.cc
src/model/DescribeParentPlatformsResult.cc
src/model/DescribePresetsRequest.cc
src/model/DescribePresetsResult.cc
src/model/DescribePurchasedDeviceRequest.cc
src/model/DescribePurchasedDeviceResult.cc
src/model/DescribePurchasedDevicesRequest.cc
src/model/DescribePurchasedDevicesResult.cc
src/model/DescribeRecordsRequest.cc
src/model/DescribeRecordsResult.cc
src/model/DescribeStreamRequest.cc
src/model/DescribeStreamResult.cc
src/model/DescribeStreamURLRequest.cc
src/model/DescribeStreamURLResult.cc
src/model/DescribeStreamVodListRequest.cc
src/model/DescribeStreamVodListResult.cc
src/model/DescribeStreamsRequest.cc
src/model/DescribeStreamsResult.cc
src/model/DescribeTemplateRequest.cc
src/model/DescribeTemplateResult.cc
src/model/DescribeTemplatesRequest.cc
src/model/DescribeTemplatesResult.cc
src/model/DescribeVodStreamURLRequest.cc
src/model/DescribeVodStreamURLResult.cc
src/model/DescribeVsCertificateDetailRequest.cc
src/model/DescribeVsCertificateDetailResult.cc
src/model/DescribeVsCertificateListRequest.cc
src/model/DescribeVsCertificateListResult.cc
src/model/DescribeVsDomainBpsDataRequest.cc
src/model/DescribeVsDomainBpsDataResult.cc
src/model/DescribeVsDomainCertificateInfoRequest.cc
src/model/DescribeVsDomainCertificateInfoResult.cc
src/model/DescribeVsDomainConfigsRequest.cc
src/model/DescribeVsDomainConfigsResult.cc
src/model/DescribeVsDomainDetailRequest.cc
src/model/DescribeVsDomainDetailResult.cc
src/model/DescribeVsDomainPvDataRequest.cc
src/model/DescribeVsDomainPvDataResult.cc
src/model/DescribeVsDomainRecordDataRequest.cc
src/model/DescribeVsDomainRecordDataResult.cc
src/model/DescribeVsDomainRegionDataRequest.cc
src/model/DescribeVsDomainRegionDataResult.cc
src/model/DescribeVsDomainReqBpsDataRequest.cc
src/model/DescribeVsDomainReqBpsDataResult.cc
src/model/DescribeVsDomainReqTrafficDataRequest.cc
src/model/DescribeVsDomainReqTrafficDataResult.cc
src/model/DescribeVsDomainSnapshotDataRequest.cc
src/model/DescribeVsDomainSnapshotDataResult.cc
src/model/DescribeVsDomainTrafficDataRequest.cc
src/model/DescribeVsDomainTrafficDataResult.cc
src/model/DescribeVsDomainUvDataRequest.cc
src/model/DescribeVsDomainUvDataResult.cc
src/model/DescribeVsPullStreamInfoConfigRequest.cc
src/model/DescribeVsPullStreamInfoConfigResult.cc
src/model/DescribeVsStreamsNotifyUrlConfigRequest.cc
src/model/DescribeVsStreamsNotifyUrlConfigResult.cc
src/model/DescribeVsStreamsOnlineListRequest.cc
src/model/DescribeVsStreamsOnlineListResult.cc
src/model/DescribeVsStreamsPublishListRequest.cc
src/model/DescribeVsStreamsPublishListResult.cc
src/model/DescribeVsTopDomainsByFlowRequest.cc
src/model/DescribeVsTopDomainsByFlowResult.cc
src/model/DescribeVsUpPeakPublishStreamDataRequest.cc
src/model/DescribeVsUpPeakPublishStreamDataResult.cc
src/model/DescribeVsUserResourcePackageRequest.cc
src/model/DescribeVsUserResourcePackageResult.cc
src/model/ForbidVsStreamRequest.cc
src/model/ForbidVsStreamResult.cc
src/model/GotoPresetRequest.cc
src/model/GotoPresetResult.cc
src/model/ModifyDeviceRequest.cc
src/model/ModifyDeviceResult.cc
src/model/ModifyDeviceAlarmRequest.cc
src/model/ModifyDeviceAlarmResult.cc
src/model/ModifyDeviceCaptureRequest.cc
src/model/ModifyDeviceCaptureResult.cc
src/model/ModifyDeviceChannelsRequest.cc
src/model/ModifyDeviceChannelsResult.cc
src/model/ModifyDirectoryRequest.cc
src/model/ModifyDirectoryResult.cc
src/model/ModifyGroupRequest.cc
src/model/ModifyGroupResult.cc
src/model/ModifyParentPlatformRequest.cc
src/model/ModifyParentPlatformResult.cc
src/model/ModifyTemplateRequest.cc
src/model/ModifyTemplateResult.cc
src/model/ResumeVsStreamRequest.cc
src/model/ResumeVsStreamResult.cc
src/model/SetPresetRequest.cc
src/model/SetPresetResult.cc
src/model/SetVsDomainCertificateRequest.cc
src/model/SetVsDomainCertificateResult.cc
src/model/SetVsStreamsNotifyUrlConfigRequest.cc
src/model/SetVsStreamsNotifyUrlConfigResult.cc
src/model/StartDeviceRequest.cc
src/model/StartDeviceResult.cc
src/model/StartParentPlatformRequest.cc
src/model/StartParentPlatformResult.cc
src/model/StartRecordStreamRequest.cc
src/model/StartRecordStreamResult.cc
src/model/StartStreamRequest.cc
src/model/StartStreamResult.cc
src/model/StartTransferStreamRequest.cc
src/model/StartTransferStreamResult.cc
src/model/StopAdjustRequest.cc
src/model/StopAdjustResult.cc
src/model/StopDeviceRequest.cc
src/model/StopDeviceResult.cc
src/model/StopMoveRequest.cc
src/model/StopMoveResult.cc
src/model/StopRecordStreamRequest.cc
src/model/StopRecordStreamResult.cc
src/model/StopStreamRequest.cc
src/model/StopStreamResult.cc
src/model/StopTransferStreamRequest.cc
src/model/StopTransferStreamResult.cc
src/model/SyncCatalogsRequest.cc
src/model/SyncCatalogsResult.cc
src/model/UnbindDirectoryRequest.cc
src/model/UnbindDirectoryResult.cc
src/model/UnbindParentPlatformDeviceRequest.cc
src/model/UnbindParentPlatformDeviceResult.cc
src/model/UnbindPurchasedDeviceRequest.cc
src/model/UnbindPurchasedDeviceResult.cc
src/model/UnbindTemplateRequest.cc
src/model/UnbindTemplateResult.cc
src/model/UnlockDeviceRequest.cc
src/model/UnlockDeviceResult.cc
src/model/UpdateVsPullStreamInfoConfigRequest.cc
src/model/UpdateVsPullStreamInfoConfigResult.cc )
add_library(vs ${LIB_TYPE}
${vs_public_header}
${vs_public_header_model}
${vs_src})
set_target_properties(vs
PROPERTIES
LINKER_LANGUAGE CXX
ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}vs
)
if(${LIB_TYPE} STREQUAL "SHARED")
set_target_properties(vs
PROPERTIES
DEFINE_SYMBOL ALIBABACLOUD_VS_LIBRARY)
endif()
target_include_directories(vs
PRIVATE include
${CMAKE_SOURCE_DIR}/core/include
)
target_link_libraries(vs
core)
if(CMAKE_HOST_WIN32)
ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
set(jsoncpp_install_dir ${INSTALL_DIR})
add_dependencies(vs
jsoncpp)
target_include_directories(vs
PRIVATE ${jsoncpp_install_dir}/include)
target_link_libraries(vs
${jsoncpp_install_dir}/lib/jsoncpp.lib)
set_target_properties(vs
PROPERTIES
COMPILE_OPTIONS "/bigobj")
else()
target_include_directories(vs
PRIVATE /usr/include/jsoncpp)
target_link_libraries(vs
jsoncpp)
endif()
install(FILES ${vs_public_header}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/vs)
install(FILES ${vs_public_header_model}
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/vs/model)
install(TARGETS vs
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

View File

@@ -0,0 +1,990 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_VS_VSCLIENT_H_
#define ALIBABACLOUD_VS_VSCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "VsExport.h"
#include "model/AddVsPullStreamInfoConfigRequest.h"
#include "model/AddVsPullStreamInfoConfigResult.h"
#include "model/BatchBindDirectoriesRequest.h"
#include "model/BatchBindDirectoriesResult.h"
#include "model/BatchBindParentPlatformDevicesRequest.h"
#include "model/BatchBindParentPlatformDevicesResult.h"
#include "model/BatchBindPurchasedDevicesRequest.h"
#include "model/BatchBindPurchasedDevicesResult.h"
#include "model/BatchBindTemplateRequest.h"
#include "model/BatchBindTemplateResult.h"
#include "model/BatchBindTemplatesRequest.h"
#include "model/BatchBindTemplatesResult.h"
#include "model/BatchDeleteDevicesRequest.h"
#include "model/BatchDeleteDevicesResult.h"
#include "model/BatchDeleteVsDomainConfigsRequest.h"
#include "model/BatchDeleteVsDomainConfigsResult.h"
#include "model/BatchForbidVsStreamRequest.h"
#include "model/BatchForbidVsStreamResult.h"
#include "model/BatchResumeVsStreamRequest.h"
#include "model/BatchResumeVsStreamResult.h"
#include "model/BatchSetVsDomainConfigsRequest.h"
#include "model/BatchSetVsDomainConfigsResult.h"
#include "model/BatchStartDevicesRequest.h"
#include "model/BatchStartDevicesResult.h"
#include "model/BatchStartStreamsRequest.h"
#include "model/BatchStartStreamsResult.h"
#include "model/BatchStopDevicesRequest.h"
#include "model/BatchStopDevicesResult.h"
#include "model/BatchStopStreamsRequest.h"
#include "model/BatchStopStreamsResult.h"
#include "model/BatchUnbindDirectoriesRequest.h"
#include "model/BatchUnbindDirectoriesResult.h"
#include "model/BatchUnbindParentPlatformDevicesRequest.h"
#include "model/BatchUnbindParentPlatformDevicesResult.h"
#include "model/BatchUnbindPurchasedDevicesRequest.h"
#include "model/BatchUnbindPurchasedDevicesResult.h"
#include "model/BatchUnbindTemplateRequest.h"
#include "model/BatchUnbindTemplateResult.h"
#include "model/BatchUnbindTemplatesRequest.h"
#include "model/BatchUnbindTemplatesResult.h"
#include "model/BindDirectoryRequest.h"
#include "model/BindDirectoryResult.h"
#include "model/BindParentPlatformDeviceRequest.h"
#include "model/BindParentPlatformDeviceResult.h"
#include "model/BindPurchasedDeviceRequest.h"
#include "model/BindPurchasedDeviceResult.h"
#include "model/BindTemplateRequest.h"
#include "model/BindTemplateResult.h"
#include "model/ContinuousAdjustRequest.h"
#include "model/ContinuousAdjustResult.h"
#include "model/ContinuousMoveRequest.h"
#include "model/ContinuousMoveResult.h"
#include "model/CreateDeviceRequest.h"
#include "model/CreateDeviceResult.h"
#include "model/CreateDeviceAlarmRequest.h"
#include "model/CreateDeviceAlarmResult.h"
#include "model/CreateDirectoryRequest.h"
#include "model/CreateDirectoryResult.h"
#include "model/CreateGroupRequest.h"
#include "model/CreateGroupResult.h"
#include "model/CreateParentPlatformRequest.h"
#include "model/CreateParentPlatformResult.h"
#include "model/CreateStreamSnapshotRequest.h"
#include "model/CreateStreamSnapshotResult.h"
#include "model/CreateTemplateRequest.h"
#include "model/CreateTemplateResult.h"
#include "model/DeleteDeviceRequest.h"
#include "model/DeleteDeviceResult.h"
#include "model/DeleteDirectoryRequest.h"
#include "model/DeleteDirectoryResult.h"
#include "model/DeleteGroupRequest.h"
#include "model/DeleteGroupResult.h"
#include "model/DeleteParentPlatformRequest.h"
#include "model/DeleteParentPlatformResult.h"
#include "model/DeletePresetRequest.h"
#include "model/DeletePresetResult.h"
#include "model/DeleteTemplateRequest.h"
#include "model/DeleteTemplateResult.h"
#include "model/DeleteVsPullStreamInfoConfigRequest.h"
#include "model/DeleteVsPullStreamInfoConfigResult.h"
#include "model/DeleteVsStreamsNotifyUrlConfigRequest.h"
#include "model/DeleteVsStreamsNotifyUrlConfigResult.h"
#include "model/DescribeAccountStatRequest.h"
#include "model/DescribeAccountStatResult.h"
#include "model/DescribeDeviceRequest.h"
#include "model/DescribeDeviceResult.h"
#include "model/DescribeDeviceChannelsRequest.h"
#include "model/DescribeDeviceChannelsResult.h"
#include "model/DescribeDeviceGatewayRequest.h"
#include "model/DescribeDeviceGatewayResult.h"
#include "model/DescribeDeviceURLRequest.h"
#include "model/DescribeDeviceURLResult.h"
#include "model/DescribeDevicesRequest.h"
#include "model/DescribeDevicesResult.h"
#include "model/DescribeDirectoriesRequest.h"
#include "model/DescribeDirectoriesResult.h"
#include "model/DescribeDirectoryRequest.h"
#include "model/DescribeDirectoryResult.h"
#include "model/DescribeGroupRequest.h"
#include "model/DescribeGroupResult.h"
#include "model/DescribeGroupsRequest.h"
#include "model/DescribeGroupsResult.h"
#include "model/DescribeParentPlatformRequest.h"
#include "model/DescribeParentPlatformResult.h"
#include "model/DescribeParentPlatformDevicesRequest.h"
#include "model/DescribeParentPlatformDevicesResult.h"
#include "model/DescribeParentPlatformsRequest.h"
#include "model/DescribeParentPlatformsResult.h"
#include "model/DescribePresetsRequest.h"
#include "model/DescribePresetsResult.h"
#include "model/DescribePurchasedDeviceRequest.h"
#include "model/DescribePurchasedDeviceResult.h"
#include "model/DescribePurchasedDevicesRequest.h"
#include "model/DescribePurchasedDevicesResult.h"
#include "model/DescribeRecordsRequest.h"
#include "model/DescribeRecordsResult.h"
#include "model/DescribeStreamRequest.h"
#include "model/DescribeStreamResult.h"
#include "model/DescribeStreamURLRequest.h"
#include "model/DescribeStreamURLResult.h"
#include "model/DescribeStreamVodListRequest.h"
#include "model/DescribeStreamVodListResult.h"
#include "model/DescribeStreamsRequest.h"
#include "model/DescribeStreamsResult.h"
#include "model/DescribeTemplateRequest.h"
#include "model/DescribeTemplateResult.h"
#include "model/DescribeTemplatesRequest.h"
#include "model/DescribeTemplatesResult.h"
#include "model/DescribeVodStreamURLRequest.h"
#include "model/DescribeVodStreamURLResult.h"
#include "model/DescribeVsCertificateDetailRequest.h"
#include "model/DescribeVsCertificateDetailResult.h"
#include "model/DescribeVsCertificateListRequest.h"
#include "model/DescribeVsCertificateListResult.h"
#include "model/DescribeVsDomainBpsDataRequest.h"
#include "model/DescribeVsDomainBpsDataResult.h"
#include "model/DescribeVsDomainCertificateInfoRequest.h"
#include "model/DescribeVsDomainCertificateInfoResult.h"
#include "model/DescribeVsDomainConfigsRequest.h"
#include "model/DescribeVsDomainConfigsResult.h"
#include "model/DescribeVsDomainDetailRequest.h"
#include "model/DescribeVsDomainDetailResult.h"
#include "model/DescribeVsDomainPvDataRequest.h"
#include "model/DescribeVsDomainPvDataResult.h"
#include "model/DescribeVsDomainRecordDataRequest.h"
#include "model/DescribeVsDomainRecordDataResult.h"
#include "model/DescribeVsDomainRegionDataRequest.h"
#include "model/DescribeVsDomainRegionDataResult.h"
#include "model/DescribeVsDomainReqBpsDataRequest.h"
#include "model/DescribeVsDomainReqBpsDataResult.h"
#include "model/DescribeVsDomainReqTrafficDataRequest.h"
#include "model/DescribeVsDomainReqTrafficDataResult.h"
#include "model/DescribeVsDomainSnapshotDataRequest.h"
#include "model/DescribeVsDomainSnapshotDataResult.h"
#include "model/DescribeVsDomainTrafficDataRequest.h"
#include "model/DescribeVsDomainTrafficDataResult.h"
#include "model/DescribeVsDomainUvDataRequest.h"
#include "model/DescribeVsDomainUvDataResult.h"
#include "model/DescribeVsPullStreamInfoConfigRequest.h"
#include "model/DescribeVsPullStreamInfoConfigResult.h"
#include "model/DescribeVsStreamsNotifyUrlConfigRequest.h"
#include "model/DescribeVsStreamsNotifyUrlConfigResult.h"
#include "model/DescribeVsStreamsOnlineListRequest.h"
#include "model/DescribeVsStreamsOnlineListResult.h"
#include "model/DescribeVsStreamsPublishListRequest.h"
#include "model/DescribeVsStreamsPublishListResult.h"
#include "model/DescribeVsTopDomainsByFlowRequest.h"
#include "model/DescribeVsTopDomainsByFlowResult.h"
#include "model/DescribeVsUpPeakPublishStreamDataRequest.h"
#include "model/DescribeVsUpPeakPublishStreamDataResult.h"
#include "model/DescribeVsUserResourcePackageRequest.h"
#include "model/DescribeVsUserResourcePackageResult.h"
#include "model/ForbidVsStreamRequest.h"
#include "model/ForbidVsStreamResult.h"
#include "model/GotoPresetRequest.h"
#include "model/GotoPresetResult.h"
#include "model/ModifyDeviceRequest.h"
#include "model/ModifyDeviceResult.h"
#include "model/ModifyDeviceAlarmRequest.h"
#include "model/ModifyDeviceAlarmResult.h"
#include "model/ModifyDeviceCaptureRequest.h"
#include "model/ModifyDeviceCaptureResult.h"
#include "model/ModifyDeviceChannelsRequest.h"
#include "model/ModifyDeviceChannelsResult.h"
#include "model/ModifyDirectoryRequest.h"
#include "model/ModifyDirectoryResult.h"
#include "model/ModifyGroupRequest.h"
#include "model/ModifyGroupResult.h"
#include "model/ModifyParentPlatformRequest.h"
#include "model/ModifyParentPlatformResult.h"
#include "model/ModifyTemplateRequest.h"
#include "model/ModifyTemplateResult.h"
#include "model/ResumeVsStreamRequest.h"
#include "model/ResumeVsStreamResult.h"
#include "model/SetPresetRequest.h"
#include "model/SetPresetResult.h"
#include "model/SetVsDomainCertificateRequest.h"
#include "model/SetVsDomainCertificateResult.h"
#include "model/SetVsStreamsNotifyUrlConfigRequest.h"
#include "model/SetVsStreamsNotifyUrlConfigResult.h"
#include "model/StartDeviceRequest.h"
#include "model/StartDeviceResult.h"
#include "model/StartParentPlatformRequest.h"
#include "model/StartParentPlatformResult.h"
#include "model/StartRecordStreamRequest.h"
#include "model/StartRecordStreamResult.h"
#include "model/StartStreamRequest.h"
#include "model/StartStreamResult.h"
#include "model/StartTransferStreamRequest.h"
#include "model/StartTransferStreamResult.h"
#include "model/StopAdjustRequest.h"
#include "model/StopAdjustResult.h"
#include "model/StopDeviceRequest.h"
#include "model/StopDeviceResult.h"
#include "model/StopMoveRequest.h"
#include "model/StopMoveResult.h"
#include "model/StopRecordStreamRequest.h"
#include "model/StopRecordStreamResult.h"
#include "model/StopStreamRequest.h"
#include "model/StopStreamResult.h"
#include "model/StopTransferStreamRequest.h"
#include "model/StopTransferStreamResult.h"
#include "model/SyncCatalogsRequest.h"
#include "model/SyncCatalogsResult.h"
#include "model/UnbindDirectoryRequest.h"
#include "model/UnbindDirectoryResult.h"
#include "model/UnbindParentPlatformDeviceRequest.h"
#include "model/UnbindParentPlatformDeviceResult.h"
#include "model/UnbindPurchasedDeviceRequest.h"
#include "model/UnbindPurchasedDeviceResult.h"
#include "model/UnbindTemplateRequest.h"
#include "model/UnbindTemplateResult.h"
#include "model/UnlockDeviceRequest.h"
#include "model/UnlockDeviceResult.h"
#include "model/UpdateVsPullStreamInfoConfigRequest.h"
#include "model/UpdateVsPullStreamInfoConfigResult.h"
namespace AlibabaCloud
{
namespace Vs
{
class ALIBABACLOUD_VS_EXPORT VsClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AddVsPullStreamInfoConfigResult> AddVsPullStreamInfoConfigOutcome;
typedef std::future<AddVsPullStreamInfoConfigOutcome> AddVsPullStreamInfoConfigOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::AddVsPullStreamInfoConfigRequest&, const AddVsPullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddVsPullStreamInfoConfigAsyncHandler;
typedef Outcome<Error, Model::BatchBindDirectoriesResult> BatchBindDirectoriesOutcome;
typedef std::future<BatchBindDirectoriesOutcome> BatchBindDirectoriesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchBindDirectoriesRequest&, const BatchBindDirectoriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchBindDirectoriesAsyncHandler;
typedef Outcome<Error, Model::BatchBindParentPlatformDevicesResult> BatchBindParentPlatformDevicesOutcome;
typedef std::future<BatchBindParentPlatformDevicesOutcome> BatchBindParentPlatformDevicesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchBindParentPlatformDevicesRequest&, const BatchBindParentPlatformDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchBindParentPlatformDevicesAsyncHandler;
typedef Outcome<Error, Model::BatchBindPurchasedDevicesResult> BatchBindPurchasedDevicesOutcome;
typedef std::future<BatchBindPurchasedDevicesOutcome> BatchBindPurchasedDevicesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchBindPurchasedDevicesRequest&, const BatchBindPurchasedDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchBindPurchasedDevicesAsyncHandler;
typedef Outcome<Error, Model::BatchBindTemplateResult> BatchBindTemplateOutcome;
typedef std::future<BatchBindTemplateOutcome> BatchBindTemplateOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchBindTemplateRequest&, const BatchBindTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchBindTemplateAsyncHandler;
typedef Outcome<Error, Model::BatchBindTemplatesResult> BatchBindTemplatesOutcome;
typedef std::future<BatchBindTemplatesOutcome> BatchBindTemplatesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchBindTemplatesRequest&, const BatchBindTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchBindTemplatesAsyncHandler;
typedef Outcome<Error, Model::BatchDeleteDevicesResult> BatchDeleteDevicesOutcome;
typedef std::future<BatchDeleteDevicesOutcome> BatchDeleteDevicesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchDeleteDevicesRequest&, const BatchDeleteDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchDeleteDevicesAsyncHandler;
typedef Outcome<Error, Model::BatchDeleteVsDomainConfigsResult> BatchDeleteVsDomainConfigsOutcome;
typedef std::future<BatchDeleteVsDomainConfigsOutcome> BatchDeleteVsDomainConfigsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchDeleteVsDomainConfigsRequest&, const BatchDeleteVsDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchDeleteVsDomainConfigsAsyncHandler;
typedef Outcome<Error, Model::BatchForbidVsStreamResult> BatchForbidVsStreamOutcome;
typedef std::future<BatchForbidVsStreamOutcome> BatchForbidVsStreamOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchForbidVsStreamRequest&, const BatchForbidVsStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchForbidVsStreamAsyncHandler;
typedef Outcome<Error, Model::BatchResumeVsStreamResult> BatchResumeVsStreamOutcome;
typedef std::future<BatchResumeVsStreamOutcome> BatchResumeVsStreamOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchResumeVsStreamRequest&, const BatchResumeVsStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchResumeVsStreamAsyncHandler;
typedef Outcome<Error, Model::BatchSetVsDomainConfigsResult> BatchSetVsDomainConfigsOutcome;
typedef std::future<BatchSetVsDomainConfigsOutcome> BatchSetVsDomainConfigsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchSetVsDomainConfigsRequest&, const BatchSetVsDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchSetVsDomainConfigsAsyncHandler;
typedef Outcome<Error, Model::BatchStartDevicesResult> BatchStartDevicesOutcome;
typedef std::future<BatchStartDevicesOutcome> BatchStartDevicesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchStartDevicesRequest&, const BatchStartDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchStartDevicesAsyncHandler;
typedef Outcome<Error, Model::BatchStartStreamsResult> BatchStartStreamsOutcome;
typedef std::future<BatchStartStreamsOutcome> BatchStartStreamsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchStartStreamsRequest&, const BatchStartStreamsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchStartStreamsAsyncHandler;
typedef Outcome<Error, Model::BatchStopDevicesResult> BatchStopDevicesOutcome;
typedef std::future<BatchStopDevicesOutcome> BatchStopDevicesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchStopDevicesRequest&, const BatchStopDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchStopDevicesAsyncHandler;
typedef Outcome<Error, Model::BatchStopStreamsResult> BatchStopStreamsOutcome;
typedef std::future<BatchStopStreamsOutcome> BatchStopStreamsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchStopStreamsRequest&, const BatchStopStreamsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchStopStreamsAsyncHandler;
typedef Outcome<Error, Model::BatchUnbindDirectoriesResult> BatchUnbindDirectoriesOutcome;
typedef std::future<BatchUnbindDirectoriesOutcome> BatchUnbindDirectoriesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchUnbindDirectoriesRequest&, const BatchUnbindDirectoriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchUnbindDirectoriesAsyncHandler;
typedef Outcome<Error, Model::BatchUnbindParentPlatformDevicesResult> BatchUnbindParentPlatformDevicesOutcome;
typedef std::future<BatchUnbindParentPlatformDevicesOutcome> BatchUnbindParentPlatformDevicesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchUnbindParentPlatformDevicesRequest&, const BatchUnbindParentPlatformDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchUnbindParentPlatformDevicesAsyncHandler;
typedef Outcome<Error, Model::BatchUnbindPurchasedDevicesResult> BatchUnbindPurchasedDevicesOutcome;
typedef std::future<BatchUnbindPurchasedDevicesOutcome> BatchUnbindPurchasedDevicesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchUnbindPurchasedDevicesRequest&, const BatchUnbindPurchasedDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchUnbindPurchasedDevicesAsyncHandler;
typedef Outcome<Error, Model::BatchUnbindTemplateResult> BatchUnbindTemplateOutcome;
typedef std::future<BatchUnbindTemplateOutcome> BatchUnbindTemplateOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchUnbindTemplateRequest&, const BatchUnbindTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchUnbindTemplateAsyncHandler;
typedef Outcome<Error, Model::BatchUnbindTemplatesResult> BatchUnbindTemplatesOutcome;
typedef std::future<BatchUnbindTemplatesOutcome> BatchUnbindTemplatesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BatchUnbindTemplatesRequest&, const BatchUnbindTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchUnbindTemplatesAsyncHandler;
typedef Outcome<Error, Model::BindDirectoryResult> BindDirectoryOutcome;
typedef std::future<BindDirectoryOutcome> BindDirectoryOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BindDirectoryRequest&, const BindDirectoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BindDirectoryAsyncHandler;
typedef Outcome<Error, Model::BindParentPlatformDeviceResult> BindParentPlatformDeviceOutcome;
typedef std::future<BindParentPlatformDeviceOutcome> BindParentPlatformDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BindParentPlatformDeviceRequest&, const BindParentPlatformDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BindParentPlatformDeviceAsyncHandler;
typedef Outcome<Error, Model::BindPurchasedDeviceResult> BindPurchasedDeviceOutcome;
typedef std::future<BindPurchasedDeviceOutcome> BindPurchasedDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BindPurchasedDeviceRequest&, const BindPurchasedDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BindPurchasedDeviceAsyncHandler;
typedef Outcome<Error, Model::BindTemplateResult> BindTemplateOutcome;
typedef std::future<BindTemplateOutcome> BindTemplateOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::BindTemplateRequest&, const BindTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BindTemplateAsyncHandler;
typedef Outcome<Error, Model::ContinuousAdjustResult> ContinuousAdjustOutcome;
typedef std::future<ContinuousAdjustOutcome> ContinuousAdjustOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ContinuousAdjustRequest&, const ContinuousAdjustOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ContinuousAdjustAsyncHandler;
typedef Outcome<Error, Model::ContinuousMoveResult> ContinuousMoveOutcome;
typedef std::future<ContinuousMoveOutcome> ContinuousMoveOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ContinuousMoveRequest&, const ContinuousMoveOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ContinuousMoveAsyncHandler;
typedef Outcome<Error, Model::CreateDeviceResult> CreateDeviceOutcome;
typedef std::future<CreateDeviceOutcome> CreateDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::CreateDeviceRequest&, const CreateDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDeviceAsyncHandler;
typedef Outcome<Error, Model::CreateDeviceAlarmResult> CreateDeviceAlarmOutcome;
typedef std::future<CreateDeviceAlarmOutcome> CreateDeviceAlarmOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::CreateDeviceAlarmRequest&, const CreateDeviceAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDeviceAlarmAsyncHandler;
typedef Outcome<Error, Model::CreateDirectoryResult> CreateDirectoryOutcome;
typedef std::future<CreateDirectoryOutcome> CreateDirectoryOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::CreateDirectoryRequest&, const CreateDirectoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDirectoryAsyncHandler;
typedef Outcome<Error, Model::CreateGroupResult> CreateGroupOutcome;
typedef std::future<CreateGroupOutcome> CreateGroupOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::CreateGroupRequest&, const CreateGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateGroupAsyncHandler;
typedef Outcome<Error, Model::CreateParentPlatformResult> CreateParentPlatformOutcome;
typedef std::future<CreateParentPlatformOutcome> CreateParentPlatformOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::CreateParentPlatformRequest&, const CreateParentPlatformOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateParentPlatformAsyncHandler;
typedef Outcome<Error, Model::CreateStreamSnapshotResult> CreateStreamSnapshotOutcome;
typedef std::future<CreateStreamSnapshotOutcome> CreateStreamSnapshotOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::CreateStreamSnapshotRequest&, const CreateStreamSnapshotOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateStreamSnapshotAsyncHandler;
typedef Outcome<Error, Model::CreateTemplateResult> CreateTemplateOutcome;
typedef std::future<CreateTemplateOutcome> CreateTemplateOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::CreateTemplateRequest&, const CreateTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateTemplateAsyncHandler;
typedef Outcome<Error, Model::DeleteDeviceResult> DeleteDeviceOutcome;
typedef std::future<DeleteDeviceOutcome> DeleteDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DeleteDeviceRequest&, const DeleteDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDeviceAsyncHandler;
typedef Outcome<Error, Model::DeleteDirectoryResult> DeleteDirectoryOutcome;
typedef std::future<DeleteDirectoryOutcome> DeleteDirectoryOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DeleteDirectoryRequest&, const DeleteDirectoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDirectoryAsyncHandler;
typedef Outcome<Error, Model::DeleteGroupResult> DeleteGroupOutcome;
typedef std::future<DeleteGroupOutcome> DeleteGroupOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DeleteGroupRequest&, const DeleteGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteGroupAsyncHandler;
typedef Outcome<Error, Model::DeleteParentPlatformResult> DeleteParentPlatformOutcome;
typedef std::future<DeleteParentPlatformOutcome> DeleteParentPlatformOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DeleteParentPlatformRequest&, const DeleteParentPlatformOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteParentPlatformAsyncHandler;
typedef Outcome<Error, Model::DeletePresetResult> DeletePresetOutcome;
typedef std::future<DeletePresetOutcome> DeletePresetOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DeletePresetRequest&, const DeletePresetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeletePresetAsyncHandler;
typedef Outcome<Error, Model::DeleteTemplateResult> DeleteTemplateOutcome;
typedef std::future<DeleteTemplateOutcome> DeleteTemplateOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DeleteTemplateRequest&, const DeleteTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteTemplateAsyncHandler;
typedef Outcome<Error, Model::DeleteVsPullStreamInfoConfigResult> DeleteVsPullStreamInfoConfigOutcome;
typedef std::future<DeleteVsPullStreamInfoConfigOutcome> DeleteVsPullStreamInfoConfigOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DeleteVsPullStreamInfoConfigRequest&, const DeleteVsPullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVsPullStreamInfoConfigAsyncHandler;
typedef Outcome<Error, Model::DeleteVsStreamsNotifyUrlConfigResult> DeleteVsStreamsNotifyUrlConfigOutcome;
typedef std::future<DeleteVsStreamsNotifyUrlConfigOutcome> DeleteVsStreamsNotifyUrlConfigOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DeleteVsStreamsNotifyUrlConfigRequest&, const DeleteVsStreamsNotifyUrlConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteVsStreamsNotifyUrlConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeAccountStatResult> DescribeAccountStatOutcome;
typedef std::future<DescribeAccountStatOutcome> DescribeAccountStatOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeAccountStatRequest&, const DescribeAccountStatOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountStatAsyncHandler;
typedef Outcome<Error, Model::DescribeDeviceResult> DescribeDeviceOutcome;
typedef std::future<DescribeDeviceOutcome> DescribeDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeDeviceRequest&, const DescribeDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDeviceAsyncHandler;
typedef Outcome<Error, Model::DescribeDeviceChannelsResult> DescribeDeviceChannelsOutcome;
typedef std::future<DescribeDeviceChannelsOutcome> DescribeDeviceChannelsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeDeviceChannelsRequest&, const DescribeDeviceChannelsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDeviceChannelsAsyncHandler;
typedef Outcome<Error, Model::DescribeDeviceGatewayResult> DescribeDeviceGatewayOutcome;
typedef std::future<DescribeDeviceGatewayOutcome> DescribeDeviceGatewayOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeDeviceGatewayRequest&, const DescribeDeviceGatewayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDeviceGatewayAsyncHandler;
typedef Outcome<Error, Model::DescribeDeviceURLResult> DescribeDeviceURLOutcome;
typedef std::future<DescribeDeviceURLOutcome> DescribeDeviceURLOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeDeviceURLRequest&, const DescribeDeviceURLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDeviceURLAsyncHandler;
typedef Outcome<Error, Model::DescribeDevicesResult> DescribeDevicesOutcome;
typedef std::future<DescribeDevicesOutcome> DescribeDevicesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeDevicesRequest&, const DescribeDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDevicesAsyncHandler;
typedef Outcome<Error, Model::DescribeDirectoriesResult> DescribeDirectoriesOutcome;
typedef std::future<DescribeDirectoriesOutcome> DescribeDirectoriesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeDirectoriesRequest&, const DescribeDirectoriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDirectoriesAsyncHandler;
typedef Outcome<Error, Model::DescribeDirectoryResult> DescribeDirectoryOutcome;
typedef std::future<DescribeDirectoryOutcome> DescribeDirectoryOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeDirectoryRequest&, const DescribeDirectoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDirectoryAsyncHandler;
typedef Outcome<Error, Model::DescribeGroupResult> DescribeGroupOutcome;
typedef std::future<DescribeGroupOutcome> DescribeGroupOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeGroupRequest&, const DescribeGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGroupAsyncHandler;
typedef Outcome<Error, Model::DescribeGroupsResult> DescribeGroupsOutcome;
typedef std::future<DescribeGroupsOutcome> DescribeGroupsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeGroupsRequest&, const DescribeGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGroupsAsyncHandler;
typedef Outcome<Error, Model::DescribeParentPlatformResult> DescribeParentPlatformOutcome;
typedef std::future<DescribeParentPlatformOutcome> DescribeParentPlatformOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeParentPlatformRequest&, const DescribeParentPlatformOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeParentPlatformAsyncHandler;
typedef Outcome<Error, Model::DescribeParentPlatformDevicesResult> DescribeParentPlatformDevicesOutcome;
typedef std::future<DescribeParentPlatformDevicesOutcome> DescribeParentPlatformDevicesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeParentPlatformDevicesRequest&, const DescribeParentPlatformDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeParentPlatformDevicesAsyncHandler;
typedef Outcome<Error, Model::DescribeParentPlatformsResult> DescribeParentPlatformsOutcome;
typedef std::future<DescribeParentPlatformsOutcome> DescribeParentPlatformsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeParentPlatformsRequest&, const DescribeParentPlatformsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeParentPlatformsAsyncHandler;
typedef Outcome<Error, Model::DescribePresetsResult> DescribePresetsOutcome;
typedef std::future<DescribePresetsOutcome> DescribePresetsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribePresetsRequest&, const DescribePresetsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePresetsAsyncHandler;
typedef Outcome<Error, Model::DescribePurchasedDeviceResult> DescribePurchasedDeviceOutcome;
typedef std::future<DescribePurchasedDeviceOutcome> DescribePurchasedDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribePurchasedDeviceRequest&, const DescribePurchasedDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePurchasedDeviceAsyncHandler;
typedef Outcome<Error, Model::DescribePurchasedDevicesResult> DescribePurchasedDevicesOutcome;
typedef std::future<DescribePurchasedDevicesOutcome> DescribePurchasedDevicesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribePurchasedDevicesRequest&, const DescribePurchasedDevicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePurchasedDevicesAsyncHandler;
typedef Outcome<Error, Model::DescribeRecordsResult> DescribeRecordsOutcome;
typedef std::future<DescribeRecordsOutcome> DescribeRecordsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeRecordsRequest&, const DescribeRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRecordsAsyncHandler;
typedef Outcome<Error, Model::DescribeStreamResult> DescribeStreamOutcome;
typedef std::future<DescribeStreamOutcome> DescribeStreamOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeStreamRequest&, const DescribeStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStreamAsyncHandler;
typedef Outcome<Error, Model::DescribeStreamURLResult> DescribeStreamURLOutcome;
typedef std::future<DescribeStreamURLOutcome> DescribeStreamURLOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeStreamURLRequest&, const DescribeStreamURLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStreamURLAsyncHandler;
typedef Outcome<Error, Model::DescribeStreamVodListResult> DescribeStreamVodListOutcome;
typedef std::future<DescribeStreamVodListOutcome> DescribeStreamVodListOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeStreamVodListRequest&, const DescribeStreamVodListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStreamVodListAsyncHandler;
typedef Outcome<Error, Model::DescribeStreamsResult> DescribeStreamsOutcome;
typedef std::future<DescribeStreamsOutcome> DescribeStreamsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeStreamsRequest&, const DescribeStreamsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStreamsAsyncHandler;
typedef Outcome<Error, Model::DescribeTemplateResult> DescribeTemplateOutcome;
typedef std::future<DescribeTemplateOutcome> DescribeTemplateOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeTemplateRequest&, const DescribeTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTemplateAsyncHandler;
typedef Outcome<Error, Model::DescribeTemplatesResult> DescribeTemplatesOutcome;
typedef std::future<DescribeTemplatesOutcome> DescribeTemplatesOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeTemplatesRequest&, const DescribeTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTemplatesAsyncHandler;
typedef Outcome<Error, Model::DescribeVodStreamURLResult> DescribeVodStreamURLOutcome;
typedef std::future<DescribeVodStreamURLOutcome> DescribeVodStreamURLOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVodStreamURLRequest&, const DescribeVodStreamURLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVodStreamURLAsyncHandler;
typedef Outcome<Error, Model::DescribeVsCertificateDetailResult> DescribeVsCertificateDetailOutcome;
typedef std::future<DescribeVsCertificateDetailOutcome> DescribeVsCertificateDetailOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsCertificateDetailRequest&, const DescribeVsCertificateDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsCertificateDetailAsyncHandler;
typedef Outcome<Error, Model::DescribeVsCertificateListResult> DescribeVsCertificateListOutcome;
typedef std::future<DescribeVsCertificateListOutcome> DescribeVsCertificateListOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsCertificateListRequest&, const DescribeVsCertificateListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsCertificateListAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainBpsDataResult> DescribeVsDomainBpsDataOutcome;
typedef std::future<DescribeVsDomainBpsDataOutcome> DescribeVsDomainBpsDataOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainBpsDataRequest&, const DescribeVsDomainBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainBpsDataAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainCertificateInfoResult> DescribeVsDomainCertificateInfoOutcome;
typedef std::future<DescribeVsDomainCertificateInfoOutcome> DescribeVsDomainCertificateInfoOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainCertificateInfoRequest&, const DescribeVsDomainCertificateInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainCertificateInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainConfigsResult> DescribeVsDomainConfigsOutcome;
typedef std::future<DescribeVsDomainConfigsOutcome> DescribeVsDomainConfigsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainConfigsRequest&, const DescribeVsDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainConfigsAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainDetailResult> DescribeVsDomainDetailOutcome;
typedef std::future<DescribeVsDomainDetailOutcome> DescribeVsDomainDetailOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainDetailRequest&, const DescribeVsDomainDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainDetailAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainPvDataResult> DescribeVsDomainPvDataOutcome;
typedef std::future<DescribeVsDomainPvDataOutcome> DescribeVsDomainPvDataOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainPvDataRequest&, const DescribeVsDomainPvDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainPvDataAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainRecordDataResult> DescribeVsDomainRecordDataOutcome;
typedef std::future<DescribeVsDomainRecordDataOutcome> DescribeVsDomainRecordDataOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainRecordDataRequest&, const DescribeVsDomainRecordDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainRecordDataAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainRegionDataResult> DescribeVsDomainRegionDataOutcome;
typedef std::future<DescribeVsDomainRegionDataOutcome> DescribeVsDomainRegionDataOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainRegionDataRequest&, const DescribeVsDomainRegionDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainRegionDataAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainReqBpsDataResult> DescribeVsDomainReqBpsDataOutcome;
typedef std::future<DescribeVsDomainReqBpsDataOutcome> DescribeVsDomainReqBpsDataOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainReqBpsDataRequest&, const DescribeVsDomainReqBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainReqBpsDataAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainReqTrafficDataResult> DescribeVsDomainReqTrafficDataOutcome;
typedef std::future<DescribeVsDomainReqTrafficDataOutcome> DescribeVsDomainReqTrafficDataOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainReqTrafficDataRequest&, const DescribeVsDomainReqTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainReqTrafficDataAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainSnapshotDataResult> DescribeVsDomainSnapshotDataOutcome;
typedef std::future<DescribeVsDomainSnapshotDataOutcome> DescribeVsDomainSnapshotDataOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainSnapshotDataRequest&, const DescribeVsDomainSnapshotDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainSnapshotDataAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainTrafficDataResult> DescribeVsDomainTrafficDataOutcome;
typedef std::future<DescribeVsDomainTrafficDataOutcome> DescribeVsDomainTrafficDataOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainTrafficDataRequest&, const DescribeVsDomainTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainTrafficDataAsyncHandler;
typedef Outcome<Error, Model::DescribeVsDomainUvDataResult> DescribeVsDomainUvDataOutcome;
typedef std::future<DescribeVsDomainUvDataOutcome> DescribeVsDomainUvDataOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsDomainUvDataRequest&, const DescribeVsDomainUvDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsDomainUvDataAsyncHandler;
typedef Outcome<Error, Model::DescribeVsPullStreamInfoConfigResult> DescribeVsPullStreamInfoConfigOutcome;
typedef std::future<DescribeVsPullStreamInfoConfigOutcome> DescribeVsPullStreamInfoConfigOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsPullStreamInfoConfigRequest&, const DescribeVsPullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsPullStreamInfoConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeVsStreamsNotifyUrlConfigResult> DescribeVsStreamsNotifyUrlConfigOutcome;
typedef std::future<DescribeVsStreamsNotifyUrlConfigOutcome> DescribeVsStreamsNotifyUrlConfigOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsStreamsNotifyUrlConfigRequest&, const DescribeVsStreamsNotifyUrlConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsStreamsNotifyUrlConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeVsStreamsOnlineListResult> DescribeVsStreamsOnlineListOutcome;
typedef std::future<DescribeVsStreamsOnlineListOutcome> DescribeVsStreamsOnlineListOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsStreamsOnlineListRequest&, const DescribeVsStreamsOnlineListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsStreamsOnlineListAsyncHandler;
typedef Outcome<Error, Model::DescribeVsStreamsPublishListResult> DescribeVsStreamsPublishListOutcome;
typedef std::future<DescribeVsStreamsPublishListOutcome> DescribeVsStreamsPublishListOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsStreamsPublishListRequest&, const DescribeVsStreamsPublishListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsStreamsPublishListAsyncHandler;
typedef Outcome<Error, Model::DescribeVsTopDomainsByFlowResult> DescribeVsTopDomainsByFlowOutcome;
typedef std::future<DescribeVsTopDomainsByFlowOutcome> DescribeVsTopDomainsByFlowOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsTopDomainsByFlowRequest&, const DescribeVsTopDomainsByFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsTopDomainsByFlowAsyncHandler;
typedef Outcome<Error, Model::DescribeVsUpPeakPublishStreamDataResult> DescribeVsUpPeakPublishStreamDataOutcome;
typedef std::future<DescribeVsUpPeakPublishStreamDataOutcome> DescribeVsUpPeakPublishStreamDataOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsUpPeakPublishStreamDataRequest&, const DescribeVsUpPeakPublishStreamDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsUpPeakPublishStreamDataAsyncHandler;
typedef Outcome<Error, Model::DescribeVsUserResourcePackageResult> DescribeVsUserResourcePackageOutcome;
typedef std::future<DescribeVsUserResourcePackageOutcome> DescribeVsUserResourcePackageOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::DescribeVsUserResourcePackageRequest&, const DescribeVsUserResourcePackageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeVsUserResourcePackageAsyncHandler;
typedef Outcome<Error, Model::ForbidVsStreamResult> ForbidVsStreamOutcome;
typedef std::future<ForbidVsStreamOutcome> ForbidVsStreamOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ForbidVsStreamRequest&, const ForbidVsStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ForbidVsStreamAsyncHandler;
typedef Outcome<Error, Model::GotoPresetResult> GotoPresetOutcome;
typedef std::future<GotoPresetOutcome> GotoPresetOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::GotoPresetRequest&, const GotoPresetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GotoPresetAsyncHandler;
typedef Outcome<Error, Model::ModifyDeviceResult> ModifyDeviceOutcome;
typedef std::future<ModifyDeviceOutcome> ModifyDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ModifyDeviceRequest&, const ModifyDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDeviceAsyncHandler;
typedef Outcome<Error, Model::ModifyDeviceAlarmResult> ModifyDeviceAlarmOutcome;
typedef std::future<ModifyDeviceAlarmOutcome> ModifyDeviceAlarmOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ModifyDeviceAlarmRequest&, const ModifyDeviceAlarmOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDeviceAlarmAsyncHandler;
typedef Outcome<Error, Model::ModifyDeviceCaptureResult> ModifyDeviceCaptureOutcome;
typedef std::future<ModifyDeviceCaptureOutcome> ModifyDeviceCaptureOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ModifyDeviceCaptureRequest&, const ModifyDeviceCaptureOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDeviceCaptureAsyncHandler;
typedef Outcome<Error, Model::ModifyDeviceChannelsResult> ModifyDeviceChannelsOutcome;
typedef std::future<ModifyDeviceChannelsOutcome> ModifyDeviceChannelsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ModifyDeviceChannelsRequest&, const ModifyDeviceChannelsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDeviceChannelsAsyncHandler;
typedef Outcome<Error, Model::ModifyDirectoryResult> ModifyDirectoryOutcome;
typedef std::future<ModifyDirectoryOutcome> ModifyDirectoryOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ModifyDirectoryRequest&, const ModifyDirectoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDirectoryAsyncHandler;
typedef Outcome<Error, Model::ModifyGroupResult> ModifyGroupOutcome;
typedef std::future<ModifyGroupOutcome> ModifyGroupOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ModifyGroupRequest&, const ModifyGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyGroupAsyncHandler;
typedef Outcome<Error, Model::ModifyParentPlatformResult> ModifyParentPlatformOutcome;
typedef std::future<ModifyParentPlatformOutcome> ModifyParentPlatformOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ModifyParentPlatformRequest&, const ModifyParentPlatformOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyParentPlatformAsyncHandler;
typedef Outcome<Error, Model::ModifyTemplateResult> ModifyTemplateOutcome;
typedef std::future<ModifyTemplateOutcome> ModifyTemplateOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ModifyTemplateRequest&, const ModifyTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyTemplateAsyncHandler;
typedef Outcome<Error, Model::ResumeVsStreamResult> ResumeVsStreamOutcome;
typedef std::future<ResumeVsStreamOutcome> ResumeVsStreamOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::ResumeVsStreamRequest&, const ResumeVsStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResumeVsStreamAsyncHandler;
typedef Outcome<Error, Model::SetPresetResult> SetPresetOutcome;
typedef std::future<SetPresetOutcome> SetPresetOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::SetPresetRequest&, const SetPresetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetPresetAsyncHandler;
typedef Outcome<Error, Model::SetVsDomainCertificateResult> SetVsDomainCertificateOutcome;
typedef std::future<SetVsDomainCertificateOutcome> SetVsDomainCertificateOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::SetVsDomainCertificateRequest&, const SetVsDomainCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetVsDomainCertificateAsyncHandler;
typedef Outcome<Error, Model::SetVsStreamsNotifyUrlConfigResult> SetVsStreamsNotifyUrlConfigOutcome;
typedef std::future<SetVsStreamsNotifyUrlConfigOutcome> SetVsStreamsNotifyUrlConfigOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::SetVsStreamsNotifyUrlConfigRequest&, const SetVsStreamsNotifyUrlConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetVsStreamsNotifyUrlConfigAsyncHandler;
typedef Outcome<Error, Model::StartDeviceResult> StartDeviceOutcome;
typedef std::future<StartDeviceOutcome> StartDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::StartDeviceRequest&, const StartDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartDeviceAsyncHandler;
typedef Outcome<Error, Model::StartParentPlatformResult> StartParentPlatformOutcome;
typedef std::future<StartParentPlatformOutcome> StartParentPlatformOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::StartParentPlatformRequest&, const StartParentPlatformOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartParentPlatformAsyncHandler;
typedef Outcome<Error, Model::StartRecordStreamResult> StartRecordStreamOutcome;
typedef std::future<StartRecordStreamOutcome> StartRecordStreamOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::StartRecordStreamRequest&, const StartRecordStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartRecordStreamAsyncHandler;
typedef Outcome<Error, Model::StartStreamResult> StartStreamOutcome;
typedef std::future<StartStreamOutcome> StartStreamOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::StartStreamRequest&, const StartStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartStreamAsyncHandler;
typedef Outcome<Error, Model::StartTransferStreamResult> StartTransferStreamOutcome;
typedef std::future<StartTransferStreamOutcome> StartTransferStreamOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::StartTransferStreamRequest&, const StartTransferStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartTransferStreamAsyncHandler;
typedef Outcome<Error, Model::StopAdjustResult> StopAdjustOutcome;
typedef std::future<StopAdjustOutcome> StopAdjustOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::StopAdjustRequest&, const StopAdjustOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopAdjustAsyncHandler;
typedef Outcome<Error, Model::StopDeviceResult> StopDeviceOutcome;
typedef std::future<StopDeviceOutcome> StopDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::StopDeviceRequest&, const StopDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopDeviceAsyncHandler;
typedef Outcome<Error, Model::StopMoveResult> StopMoveOutcome;
typedef std::future<StopMoveOutcome> StopMoveOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::StopMoveRequest&, const StopMoveOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopMoveAsyncHandler;
typedef Outcome<Error, Model::StopRecordStreamResult> StopRecordStreamOutcome;
typedef std::future<StopRecordStreamOutcome> StopRecordStreamOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::StopRecordStreamRequest&, const StopRecordStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopRecordStreamAsyncHandler;
typedef Outcome<Error, Model::StopStreamResult> StopStreamOutcome;
typedef std::future<StopStreamOutcome> StopStreamOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::StopStreamRequest&, const StopStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopStreamAsyncHandler;
typedef Outcome<Error, Model::StopTransferStreamResult> StopTransferStreamOutcome;
typedef std::future<StopTransferStreamOutcome> StopTransferStreamOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::StopTransferStreamRequest&, const StopTransferStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopTransferStreamAsyncHandler;
typedef Outcome<Error, Model::SyncCatalogsResult> SyncCatalogsOutcome;
typedef std::future<SyncCatalogsOutcome> SyncCatalogsOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::SyncCatalogsRequest&, const SyncCatalogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SyncCatalogsAsyncHandler;
typedef Outcome<Error, Model::UnbindDirectoryResult> UnbindDirectoryOutcome;
typedef std::future<UnbindDirectoryOutcome> UnbindDirectoryOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::UnbindDirectoryRequest&, const UnbindDirectoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnbindDirectoryAsyncHandler;
typedef Outcome<Error, Model::UnbindParentPlatformDeviceResult> UnbindParentPlatformDeviceOutcome;
typedef std::future<UnbindParentPlatformDeviceOutcome> UnbindParentPlatformDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::UnbindParentPlatformDeviceRequest&, const UnbindParentPlatformDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnbindParentPlatformDeviceAsyncHandler;
typedef Outcome<Error, Model::UnbindPurchasedDeviceResult> UnbindPurchasedDeviceOutcome;
typedef std::future<UnbindPurchasedDeviceOutcome> UnbindPurchasedDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::UnbindPurchasedDeviceRequest&, const UnbindPurchasedDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnbindPurchasedDeviceAsyncHandler;
typedef Outcome<Error, Model::UnbindTemplateResult> UnbindTemplateOutcome;
typedef std::future<UnbindTemplateOutcome> UnbindTemplateOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::UnbindTemplateRequest&, const UnbindTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnbindTemplateAsyncHandler;
typedef Outcome<Error, Model::UnlockDeviceResult> UnlockDeviceOutcome;
typedef std::future<UnlockDeviceOutcome> UnlockDeviceOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::UnlockDeviceRequest&, const UnlockDeviceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UnlockDeviceAsyncHandler;
typedef Outcome<Error, Model::UpdateVsPullStreamInfoConfigResult> UpdateVsPullStreamInfoConfigOutcome;
typedef std::future<UpdateVsPullStreamInfoConfigOutcome> UpdateVsPullStreamInfoConfigOutcomeCallable;
typedef std::function<void(const VsClient*, const Model::UpdateVsPullStreamInfoConfigRequest&, const UpdateVsPullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateVsPullStreamInfoConfigAsyncHandler;
VsClient(const Credentials &credentials, const ClientConfiguration &configuration);
VsClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
VsClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~VsClient();
AddVsPullStreamInfoConfigOutcome addVsPullStreamInfoConfig(const Model::AddVsPullStreamInfoConfigRequest &request)const;
void addVsPullStreamInfoConfigAsync(const Model::AddVsPullStreamInfoConfigRequest& request, const AddVsPullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddVsPullStreamInfoConfigOutcomeCallable addVsPullStreamInfoConfigCallable(const Model::AddVsPullStreamInfoConfigRequest& request) const;
BatchBindDirectoriesOutcome batchBindDirectories(const Model::BatchBindDirectoriesRequest &request)const;
void batchBindDirectoriesAsync(const Model::BatchBindDirectoriesRequest& request, const BatchBindDirectoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchBindDirectoriesOutcomeCallable batchBindDirectoriesCallable(const Model::BatchBindDirectoriesRequest& request) const;
BatchBindParentPlatformDevicesOutcome batchBindParentPlatformDevices(const Model::BatchBindParentPlatformDevicesRequest &request)const;
void batchBindParentPlatformDevicesAsync(const Model::BatchBindParentPlatformDevicesRequest& request, const BatchBindParentPlatformDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchBindParentPlatformDevicesOutcomeCallable batchBindParentPlatformDevicesCallable(const Model::BatchBindParentPlatformDevicesRequest& request) const;
BatchBindPurchasedDevicesOutcome batchBindPurchasedDevices(const Model::BatchBindPurchasedDevicesRequest &request)const;
void batchBindPurchasedDevicesAsync(const Model::BatchBindPurchasedDevicesRequest& request, const BatchBindPurchasedDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchBindPurchasedDevicesOutcomeCallable batchBindPurchasedDevicesCallable(const Model::BatchBindPurchasedDevicesRequest& request) const;
BatchBindTemplateOutcome batchBindTemplate(const Model::BatchBindTemplateRequest &request)const;
void batchBindTemplateAsync(const Model::BatchBindTemplateRequest& request, const BatchBindTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchBindTemplateOutcomeCallable batchBindTemplateCallable(const Model::BatchBindTemplateRequest& request) const;
BatchBindTemplatesOutcome batchBindTemplates(const Model::BatchBindTemplatesRequest &request)const;
void batchBindTemplatesAsync(const Model::BatchBindTemplatesRequest& request, const BatchBindTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchBindTemplatesOutcomeCallable batchBindTemplatesCallable(const Model::BatchBindTemplatesRequest& request) const;
BatchDeleteDevicesOutcome batchDeleteDevices(const Model::BatchDeleteDevicesRequest &request)const;
void batchDeleteDevicesAsync(const Model::BatchDeleteDevicesRequest& request, const BatchDeleteDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchDeleteDevicesOutcomeCallable batchDeleteDevicesCallable(const Model::BatchDeleteDevicesRequest& request) const;
BatchDeleteVsDomainConfigsOutcome batchDeleteVsDomainConfigs(const Model::BatchDeleteVsDomainConfigsRequest &request)const;
void batchDeleteVsDomainConfigsAsync(const Model::BatchDeleteVsDomainConfigsRequest& request, const BatchDeleteVsDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchDeleteVsDomainConfigsOutcomeCallable batchDeleteVsDomainConfigsCallable(const Model::BatchDeleteVsDomainConfigsRequest& request) const;
BatchForbidVsStreamOutcome batchForbidVsStream(const Model::BatchForbidVsStreamRequest &request)const;
void batchForbidVsStreamAsync(const Model::BatchForbidVsStreamRequest& request, const BatchForbidVsStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchForbidVsStreamOutcomeCallable batchForbidVsStreamCallable(const Model::BatchForbidVsStreamRequest& request) const;
BatchResumeVsStreamOutcome batchResumeVsStream(const Model::BatchResumeVsStreamRequest &request)const;
void batchResumeVsStreamAsync(const Model::BatchResumeVsStreamRequest& request, const BatchResumeVsStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchResumeVsStreamOutcomeCallable batchResumeVsStreamCallable(const Model::BatchResumeVsStreamRequest& request) const;
BatchSetVsDomainConfigsOutcome batchSetVsDomainConfigs(const Model::BatchSetVsDomainConfigsRequest &request)const;
void batchSetVsDomainConfigsAsync(const Model::BatchSetVsDomainConfigsRequest& request, const BatchSetVsDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchSetVsDomainConfigsOutcomeCallable batchSetVsDomainConfigsCallable(const Model::BatchSetVsDomainConfigsRequest& request) const;
BatchStartDevicesOutcome batchStartDevices(const Model::BatchStartDevicesRequest &request)const;
void batchStartDevicesAsync(const Model::BatchStartDevicesRequest& request, const BatchStartDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchStartDevicesOutcomeCallable batchStartDevicesCallable(const Model::BatchStartDevicesRequest& request) const;
BatchStartStreamsOutcome batchStartStreams(const Model::BatchStartStreamsRequest &request)const;
void batchStartStreamsAsync(const Model::BatchStartStreamsRequest& request, const BatchStartStreamsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchStartStreamsOutcomeCallable batchStartStreamsCallable(const Model::BatchStartStreamsRequest& request) const;
BatchStopDevicesOutcome batchStopDevices(const Model::BatchStopDevicesRequest &request)const;
void batchStopDevicesAsync(const Model::BatchStopDevicesRequest& request, const BatchStopDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchStopDevicesOutcomeCallable batchStopDevicesCallable(const Model::BatchStopDevicesRequest& request) const;
BatchStopStreamsOutcome batchStopStreams(const Model::BatchStopStreamsRequest &request)const;
void batchStopStreamsAsync(const Model::BatchStopStreamsRequest& request, const BatchStopStreamsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchStopStreamsOutcomeCallable batchStopStreamsCallable(const Model::BatchStopStreamsRequest& request) const;
BatchUnbindDirectoriesOutcome batchUnbindDirectories(const Model::BatchUnbindDirectoriesRequest &request)const;
void batchUnbindDirectoriesAsync(const Model::BatchUnbindDirectoriesRequest& request, const BatchUnbindDirectoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchUnbindDirectoriesOutcomeCallable batchUnbindDirectoriesCallable(const Model::BatchUnbindDirectoriesRequest& request) const;
BatchUnbindParentPlatformDevicesOutcome batchUnbindParentPlatformDevices(const Model::BatchUnbindParentPlatformDevicesRequest &request)const;
void batchUnbindParentPlatformDevicesAsync(const Model::BatchUnbindParentPlatformDevicesRequest& request, const BatchUnbindParentPlatformDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchUnbindParentPlatformDevicesOutcomeCallable batchUnbindParentPlatformDevicesCallable(const Model::BatchUnbindParentPlatformDevicesRequest& request) const;
BatchUnbindPurchasedDevicesOutcome batchUnbindPurchasedDevices(const Model::BatchUnbindPurchasedDevicesRequest &request)const;
void batchUnbindPurchasedDevicesAsync(const Model::BatchUnbindPurchasedDevicesRequest& request, const BatchUnbindPurchasedDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchUnbindPurchasedDevicesOutcomeCallable batchUnbindPurchasedDevicesCallable(const Model::BatchUnbindPurchasedDevicesRequest& request) const;
BatchUnbindTemplateOutcome batchUnbindTemplate(const Model::BatchUnbindTemplateRequest &request)const;
void batchUnbindTemplateAsync(const Model::BatchUnbindTemplateRequest& request, const BatchUnbindTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchUnbindTemplateOutcomeCallable batchUnbindTemplateCallable(const Model::BatchUnbindTemplateRequest& request) const;
BatchUnbindTemplatesOutcome batchUnbindTemplates(const Model::BatchUnbindTemplatesRequest &request)const;
void batchUnbindTemplatesAsync(const Model::BatchUnbindTemplatesRequest& request, const BatchUnbindTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BatchUnbindTemplatesOutcomeCallable batchUnbindTemplatesCallable(const Model::BatchUnbindTemplatesRequest& request) const;
BindDirectoryOutcome bindDirectory(const Model::BindDirectoryRequest &request)const;
void bindDirectoryAsync(const Model::BindDirectoryRequest& request, const BindDirectoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BindDirectoryOutcomeCallable bindDirectoryCallable(const Model::BindDirectoryRequest& request) const;
BindParentPlatformDeviceOutcome bindParentPlatformDevice(const Model::BindParentPlatformDeviceRequest &request)const;
void bindParentPlatformDeviceAsync(const Model::BindParentPlatformDeviceRequest& request, const BindParentPlatformDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BindParentPlatformDeviceOutcomeCallable bindParentPlatformDeviceCallable(const Model::BindParentPlatformDeviceRequest& request) const;
BindPurchasedDeviceOutcome bindPurchasedDevice(const Model::BindPurchasedDeviceRequest &request)const;
void bindPurchasedDeviceAsync(const Model::BindPurchasedDeviceRequest& request, const BindPurchasedDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BindPurchasedDeviceOutcomeCallable bindPurchasedDeviceCallable(const Model::BindPurchasedDeviceRequest& request) const;
BindTemplateOutcome bindTemplate(const Model::BindTemplateRequest &request)const;
void bindTemplateAsync(const Model::BindTemplateRequest& request, const BindTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
BindTemplateOutcomeCallable bindTemplateCallable(const Model::BindTemplateRequest& request) const;
ContinuousAdjustOutcome continuousAdjust(const Model::ContinuousAdjustRequest &request)const;
void continuousAdjustAsync(const Model::ContinuousAdjustRequest& request, const ContinuousAdjustAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ContinuousAdjustOutcomeCallable continuousAdjustCallable(const Model::ContinuousAdjustRequest& request) const;
ContinuousMoveOutcome continuousMove(const Model::ContinuousMoveRequest &request)const;
void continuousMoveAsync(const Model::ContinuousMoveRequest& request, const ContinuousMoveAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ContinuousMoveOutcomeCallable continuousMoveCallable(const Model::ContinuousMoveRequest& request) const;
CreateDeviceOutcome createDevice(const Model::CreateDeviceRequest &request)const;
void createDeviceAsync(const Model::CreateDeviceRequest& request, const CreateDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDeviceOutcomeCallable createDeviceCallable(const Model::CreateDeviceRequest& request) const;
CreateDeviceAlarmOutcome createDeviceAlarm(const Model::CreateDeviceAlarmRequest &request)const;
void createDeviceAlarmAsync(const Model::CreateDeviceAlarmRequest& request, const CreateDeviceAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDeviceAlarmOutcomeCallable createDeviceAlarmCallable(const Model::CreateDeviceAlarmRequest& request) const;
CreateDirectoryOutcome createDirectory(const Model::CreateDirectoryRequest &request)const;
void createDirectoryAsync(const Model::CreateDirectoryRequest& request, const CreateDirectoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDirectoryOutcomeCallable createDirectoryCallable(const Model::CreateDirectoryRequest& request) const;
CreateGroupOutcome createGroup(const Model::CreateGroupRequest &request)const;
void createGroupAsync(const Model::CreateGroupRequest& request, const CreateGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateGroupOutcomeCallable createGroupCallable(const Model::CreateGroupRequest& request) const;
CreateParentPlatformOutcome createParentPlatform(const Model::CreateParentPlatformRequest &request)const;
void createParentPlatformAsync(const Model::CreateParentPlatformRequest& request, const CreateParentPlatformAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateParentPlatformOutcomeCallable createParentPlatformCallable(const Model::CreateParentPlatformRequest& request) const;
CreateStreamSnapshotOutcome createStreamSnapshot(const Model::CreateStreamSnapshotRequest &request)const;
void createStreamSnapshotAsync(const Model::CreateStreamSnapshotRequest& request, const CreateStreamSnapshotAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateStreamSnapshotOutcomeCallable createStreamSnapshotCallable(const Model::CreateStreamSnapshotRequest& request) const;
CreateTemplateOutcome createTemplate(const Model::CreateTemplateRequest &request)const;
void createTemplateAsync(const Model::CreateTemplateRequest& request, const CreateTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateTemplateOutcomeCallable createTemplateCallable(const Model::CreateTemplateRequest& request) const;
DeleteDeviceOutcome deleteDevice(const Model::DeleteDeviceRequest &request)const;
void deleteDeviceAsync(const Model::DeleteDeviceRequest& request, const DeleteDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDeviceOutcomeCallable deleteDeviceCallable(const Model::DeleteDeviceRequest& request) const;
DeleteDirectoryOutcome deleteDirectory(const Model::DeleteDirectoryRequest &request)const;
void deleteDirectoryAsync(const Model::DeleteDirectoryRequest& request, const DeleteDirectoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDirectoryOutcomeCallable deleteDirectoryCallable(const Model::DeleteDirectoryRequest& request) const;
DeleteGroupOutcome deleteGroup(const Model::DeleteGroupRequest &request)const;
void deleteGroupAsync(const Model::DeleteGroupRequest& request, const DeleteGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteGroupOutcomeCallable deleteGroupCallable(const Model::DeleteGroupRequest& request) const;
DeleteParentPlatformOutcome deleteParentPlatform(const Model::DeleteParentPlatformRequest &request)const;
void deleteParentPlatformAsync(const Model::DeleteParentPlatformRequest& request, const DeleteParentPlatformAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteParentPlatformOutcomeCallable deleteParentPlatformCallable(const Model::DeleteParentPlatformRequest& request) const;
DeletePresetOutcome deletePreset(const Model::DeletePresetRequest &request)const;
void deletePresetAsync(const Model::DeletePresetRequest& request, const DeletePresetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeletePresetOutcomeCallable deletePresetCallable(const Model::DeletePresetRequest& request) const;
DeleteTemplateOutcome deleteTemplate(const Model::DeleteTemplateRequest &request)const;
void deleteTemplateAsync(const Model::DeleteTemplateRequest& request, const DeleteTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteTemplateOutcomeCallable deleteTemplateCallable(const Model::DeleteTemplateRequest& request) const;
DeleteVsPullStreamInfoConfigOutcome deleteVsPullStreamInfoConfig(const Model::DeleteVsPullStreamInfoConfigRequest &request)const;
void deleteVsPullStreamInfoConfigAsync(const Model::DeleteVsPullStreamInfoConfigRequest& request, const DeleteVsPullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteVsPullStreamInfoConfigOutcomeCallable deleteVsPullStreamInfoConfigCallable(const Model::DeleteVsPullStreamInfoConfigRequest& request) const;
DeleteVsStreamsNotifyUrlConfigOutcome deleteVsStreamsNotifyUrlConfig(const Model::DeleteVsStreamsNotifyUrlConfigRequest &request)const;
void deleteVsStreamsNotifyUrlConfigAsync(const Model::DeleteVsStreamsNotifyUrlConfigRequest& request, const DeleteVsStreamsNotifyUrlConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteVsStreamsNotifyUrlConfigOutcomeCallable deleteVsStreamsNotifyUrlConfigCallable(const Model::DeleteVsStreamsNotifyUrlConfigRequest& request) const;
DescribeAccountStatOutcome describeAccountStat(const Model::DescribeAccountStatRequest &request)const;
void describeAccountStatAsync(const Model::DescribeAccountStatRequest& request, const DescribeAccountStatAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccountStatOutcomeCallable describeAccountStatCallable(const Model::DescribeAccountStatRequest& request) const;
DescribeDeviceOutcome describeDevice(const Model::DescribeDeviceRequest &request)const;
void describeDeviceAsync(const Model::DescribeDeviceRequest& request, const DescribeDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDeviceOutcomeCallable describeDeviceCallable(const Model::DescribeDeviceRequest& request) const;
DescribeDeviceChannelsOutcome describeDeviceChannels(const Model::DescribeDeviceChannelsRequest &request)const;
void describeDeviceChannelsAsync(const Model::DescribeDeviceChannelsRequest& request, const DescribeDeviceChannelsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDeviceChannelsOutcomeCallable describeDeviceChannelsCallable(const Model::DescribeDeviceChannelsRequest& request) const;
DescribeDeviceGatewayOutcome describeDeviceGateway(const Model::DescribeDeviceGatewayRequest &request)const;
void describeDeviceGatewayAsync(const Model::DescribeDeviceGatewayRequest& request, const DescribeDeviceGatewayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDeviceGatewayOutcomeCallable describeDeviceGatewayCallable(const Model::DescribeDeviceGatewayRequest& request) const;
DescribeDeviceURLOutcome describeDeviceURL(const Model::DescribeDeviceURLRequest &request)const;
void describeDeviceURLAsync(const Model::DescribeDeviceURLRequest& request, const DescribeDeviceURLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDeviceURLOutcomeCallable describeDeviceURLCallable(const Model::DescribeDeviceURLRequest& request) const;
DescribeDevicesOutcome describeDevices(const Model::DescribeDevicesRequest &request)const;
void describeDevicesAsync(const Model::DescribeDevicesRequest& request, const DescribeDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDevicesOutcomeCallable describeDevicesCallable(const Model::DescribeDevicesRequest& request) const;
DescribeDirectoriesOutcome describeDirectories(const Model::DescribeDirectoriesRequest &request)const;
void describeDirectoriesAsync(const Model::DescribeDirectoriesRequest& request, const DescribeDirectoriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDirectoriesOutcomeCallable describeDirectoriesCallable(const Model::DescribeDirectoriesRequest& request) const;
DescribeDirectoryOutcome describeDirectory(const Model::DescribeDirectoryRequest &request)const;
void describeDirectoryAsync(const Model::DescribeDirectoryRequest& request, const DescribeDirectoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDirectoryOutcomeCallable describeDirectoryCallable(const Model::DescribeDirectoryRequest& request) const;
DescribeGroupOutcome describeGroup(const Model::DescribeGroupRequest &request)const;
void describeGroupAsync(const Model::DescribeGroupRequest& request, const DescribeGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGroupOutcomeCallable describeGroupCallable(const Model::DescribeGroupRequest& request) const;
DescribeGroupsOutcome describeGroups(const Model::DescribeGroupsRequest &request)const;
void describeGroupsAsync(const Model::DescribeGroupsRequest& request, const DescribeGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGroupsOutcomeCallable describeGroupsCallable(const Model::DescribeGroupsRequest& request) const;
DescribeParentPlatformOutcome describeParentPlatform(const Model::DescribeParentPlatformRequest &request)const;
void describeParentPlatformAsync(const Model::DescribeParentPlatformRequest& request, const DescribeParentPlatformAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeParentPlatformOutcomeCallable describeParentPlatformCallable(const Model::DescribeParentPlatformRequest& request) const;
DescribeParentPlatformDevicesOutcome describeParentPlatformDevices(const Model::DescribeParentPlatformDevicesRequest &request)const;
void describeParentPlatformDevicesAsync(const Model::DescribeParentPlatformDevicesRequest& request, const DescribeParentPlatformDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeParentPlatformDevicesOutcomeCallable describeParentPlatformDevicesCallable(const Model::DescribeParentPlatformDevicesRequest& request) const;
DescribeParentPlatformsOutcome describeParentPlatforms(const Model::DescribeParentPlatformsRequest &request)const;
void describeParentPlatformsAsync(const Model::DescribeParentPlatformsRequest& request, const DescribeParentPlatformsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeParentPlatformsOutcomeCallable describeParentPlatformsCallable(const Model::DescribeParentPlatformsRequest& request) const;
DescribePresetsOutcome describePresets(const Model::DescribePresetsRequest &request)const;
void describePresetsAsync(const Model::DescribePresetsRequest& request, const DescribePresetsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePresetsOutcomeCallable describePresetsCallable(const Model::DescribePresetsRequest& request) const;
DescribePurchasedDeviceOutcome describePurchasedDevice(const Model::DescribePurchasedDeviceRequest &request)const;
void describePurchasedDeviceAsync(const Model::DescribePurchasedDeviceRequest& request, const DescribePurchasedDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePurchasedDeviceOutcomeCallable describePurchasedDeviceCallable(const Model::DescribePurchasedDeviceRequest& request) const;
DescribePurchasedDevicesOutcome describePurchasedDevices(const Model::DescribePurchasedDevicesRequest &request)const;
void describePurchasedDevicesAsync(const Model::DescribePurchasedDevicesRequest& request, const DescribePurchasedDevicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePurchasedDevicesOutcomeCallable describePurchasedDevicesCallable(const Model::DescribePurchasedDevicesRequest& request) const;
DescribeRecordsOutcome describeRecords(const Model::DescribeRecordsRequest &request)const;
void describeRecordsAsync(const Model::DescribeRecordsRequest& request, const DescribeRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRecordsOutcomeCallable describeRecordsCallable(const Model::DescribeRecordsRequest& request) const;
DescribeStreamOutcome describeStream(const Model::DescribeStreamRequest &request)const;
void describeStreamAsync(const Model::DescribeStreamRequest& request, const DescribeStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeStreamOutcomeCallable describeStreamCallable(const Model::DescribeStreamRequest& request) const;
DescribeStreamURLOutcome describeStreamURL(const Model::DescribeStreamURLRequest &request)const;
void describeStreamURLAsync(const Model::DescribeStreamURLRequest& request, const DescribeStreamURLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeStreamURLOutcomeCallable describeStreamURLCallable(const Model::DescribeStreamURLRequest& request) const;
DescribeStreamVodListOutcome describeStreamVodList(const Model::DescribeStreamVodListRequest &request)const;
void describeStreamVodListAsync(const Model::DescribeStreamVodListRequest& request, const DescribeStreamVodListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeStreamVodListOutcomeCallable describeStreamVodListCallable(const Model::DescribeStreamVodListRequest& request) const;
DescribeStreamsOutcome describeStreams(const Model::DescribeStreamsRequest &request)const;
void describeStreamsAsync(const Model::DescribeStreamsRequest& request, const DescribeStreamsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeStreamsOutcomeCallable describeStreamsCallable(const Model::DescribeStreamsRequest& request) const;
DescribeTemplateOutcome describeTemplate(const Model::DescribeTemplateRequest &request)const;
void describeTemplateAsync(const Model::DescribeTemplateRequest& request, const DescribeTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeTemplateOutcomeCallable describeTemplateCallable(const Model::DescribeTemplateRequest& request) const;
DescribeTemplatesOutcome describeTemplates(const Model::DescribeTemplatesRequest &request)const;
void describeTemplatesAsync(const Model::DescribeTemplatesRequest& request, const DescribeTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeTemplatesOutcomeCallable describeTemplatesCallable(const Model::DescribeTemplatesRequest& request) const;
DescribeVodStreamURLOutcome describeVodStreamURL(const Model::DescribeVodStreamURLRequest &request)const;
void describeVodStreamURLAsync(const Model::DescribeVodStreamURLRequest& request, const DescribeVodStreamURLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVodStreamURLOutcomeCallable describeVodStreamURLCallable(const Model::DescribeVodStreamURLRequest& request) const;
DescribeVsCertificateDetailOutcome describeVsCertificateDetail(const Model::DescribeVsCertificateDetailRequest &request)const;
void describeVsCertificateDetailAsync(const Model::DescribeVsCertificateDetailRequest& request, const DescribeVsCertificateDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsCertificateDetailOutcomeCallable describeVsCertificateDetailCallable(const Model::DescribeVsCertificateDetailRequest& request) const;
DescribeVsCertificateListOutcome describeVsCertificateList(const Model::DescribeVsCertificateListRequest &request)const;
void describeVsCertificateListAsync(const Model::DescribeVsCertificateListRequest& request, const DescribeVsCertificateListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsCertificateListOutcomeCallable describeVsCertificateListCallable(const Model::DescribeVsCertificateListRequest& request) const;
DescribeVsDomainBpsDataOutcome describeVsDomainBpsData(const Model::DescribeVsDomainBpsDataRequest &request)const;
void describeVsDomainBpsDataAsync(const Model::DescribeVsDomainBpsDataRequest& request, const DescribeVsDomainBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainBpsDataOutcomeCallable describeVsDomainBpsDataCallable(const Model::DescribeVsDomainBpsDataRequest& request) const;
DescribeVsDomainCertificateInfoOutcome describeVsDomainCertificateInfo(const Model::DescribeVsDomainCertificateInfoRequest &request)const;
void describeVsDomainCertificateInfoAsync(const Model::DescribeVsDomainCertificateInfoRequest& request, const DescribeVsDomainCertificateInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainCertificateInfoOutcomeCallable describeVsDomainCertificateInfoCallable(const Model::DescribeVsDomainCertificateInfoRequest& request) const;
DescribeVsDomainConfigsOutcome describeVsDomainConfigs(const Model::DescribeVsDomainConfigsRequest &request)const;
void describeVsDomainConfigsAsync(const Model::DescribeVsDomainConfigsRequest& request, const DescribeVsDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainConfigsOutcomeCallable describeVsDomainConfigsCallable(const Model::DescribeVsDomainConfigsRequest& request) const;
DescribeVsDomainDetailOutcome describeVsDomainDetail(const Model::DescribeVsDomainDetailRequest &request)const;
void describeVsDomainDetailAsync(const Model::DescribeVsDomainDetailRequest& request, const DescribeVsDomainDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainDetailOutcomeCallable describeVsDomainDetailCallable(const Model::DescribeVsDomainDetailRequest& request) const;
DescribeVsDomainPvDataOutcome describeVsDomainPvData(const Model::DescribeVsDomainPvDataRequest &request)const;
void describeVsDomainPvDataAsync(const Model::DescribeVsDomainPvDataRequest& request, const DescribeVsDomainPvDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainPvDataOutcomeCallable describeVsDomainPvDataCallable(const Model::DescribeVsDomainPvDataRequest& request) const;
DescribeVsDomainRecordDataOutcome describeVsDomainRecordData(const Model::DescribeVsDomainRecordDataRequest &request)const;
void describeVsDomainRecordDataAsync(const Model::DescribeVsDomainRecordDataRequest& request, const DescribeVsDomainRecordDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainRecordDataOutcomeCallable describeVsDomainRecordDataCallable(const Model::DescribeVsDomainRecordDataRequest& request) const;
DescribeVsDomainRegionDataOutcome describeVsDomainRegionData(const Model::DescribeVsDomainRegionDataRequest &request)const;
void describeVsDomainRegionDataAsync(const Model::DescribeVsDomainRegionDataRequest& request, const DescribeVsDomainRegionDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainRegionDataOutcomeCallable describeVsDomainRegionDataCallable(const Model::DescribeVsDomainRegionDataRequest& request) const;
DescribeVsDomainReqBpsDataOutcome describeVsDomainReqBpsData(const Model::DescribeVsDomainReqBpsDataRequest &request)const;
void describeVsDomainReqBpsDataAsync(const Model::DescribeVsDomainReqBpsDataRequest& request, const DescribeVsDomainReqBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainReqBpsDataOutcomeCallable describeVsDomainReqBpsDataCallable(const Model::DescribeVsDomainReqBpsDataRequest& request) const;
DescribeVsDomainReqTrafficDataOutcome describeVsDomainReqTrafficData(const Model::DescribeVsDomainReqTrafficDataRequest &request)const;
void describeVsDomainReqTrafficDataAsync(const Model::DescribeVsDomainReqTrafficDataRequest& request, const DescribeVsDomainReqTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainReqTrafficDataOutcomeCallable describeVsDomainReqTrafficDataCallable(const Model::DescribeVsDomainReqTrafficDataRequest& request) const;
DescribeVsDomainSnapshotDataOutcome describeVsDomainSnapshotData(const Model::DescribeVsDomainSnapshotDataRequest &request)const;
void describeVsDomainSnapshotDataAsync(const Model::DescribeVsDomainSnapshotDataRequest& request, const DescribeVsDomainSnapshotDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainSnapshotDataOutcomeCallable describeVsDomainSnapshotDataCallable(const Model::DescribeVsDomainSnapshotDataRequest& request) const;
DescribeVsDomainTrafficDataOutcome describeVsDomainTrafficData(const Model::DescribeVsDomainTrafficDataRequest &request)const;
void describeVsDomainTrafficDataAsync(const Model::DescribeVsDomainTrafficDataRequest& request, const DescribeVsDomainTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainTrafficDataOutcomeCallable describeVsDomainTrafficDataCallable(const Model::DescribeVsDomainTrafficDataRequest& request) const;
DescribeVsDomainUvDataOutcome describeVsDomainUvData(const Model::DescribeVsDomainUvDataRequest &request)const;
void describeVsDomainUvDataAsync(const Model::DescribeVsDomainUvDataRequest& request, const DescribeVsDomainUvDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsDomainUvDataOutcomeCallable describeVsDomainUvDataCallable(const Model::DescribeVsDomainUvDataRequest& request) const;
DescribeVsPullStreamInfoConfigOutcome describeVsPullStreamInfoConfig(const Model::DescribeVsPullStreamInfoConfigRequest &request)const;
void describeVsPullStreamInfoConfigAsync(const Model::DescribeVsPullStreamInfoConfigRequest& request, const DescribeVsPullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsPullStreamInfoConfigOutcomeCallable describeVsPullStreamInfoConfigCallable(const Model::DescribeVsPullStreamInfoConfigRequest& request) const;
DescribeVsStreamsNotifyUrlConfigOutcome describeVsStreamsNotifyUrlConfig(const Model::DescribeVsStreamsNotifyUrlConfigRequest &request)const;
void describeVsStreamsNotifyUrlConfigAsync(const Model::DescribeVsStreamsNotifyUrlConfigRequest& request, const DescribeVsStreamsNotifyUrlConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsStreamsNotifyUrlConfigOutcomeCallable describeVsStreamsNotifyUrlConfigCallable(const Model::DescribeVsStreamsNotifyUrlConfigRequest& request) const;
DescribeVsStreamsOnlineListOutcome describeVsStreamsOnlineList(const Model::DescribeVsStreamsOnlineListRequest &request)const;
void describeVsStreamsOnlineListAsync(const Model::DescribeVsStreamsOnlineListRequest& request, const DescribeVsStreamsOnlineListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsStreamsOnlineListOutcomeCallable describeVsStreamsOnlineListCallable(const Model::DescribeVsStreamsOnlineListRequest& request) const;
DescribeVsStreamsPublishListOutcome describeVsStreamsPublishList(const Model::DescribeVsStreamsPublishListRequest &request)const;
void describeVsStreamsPublishListAsync(const Model::DescribeVsStreamsPublishListRequest& request, const DescribeVsStreamsPublishListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsStreamsPublishListOutcomeCallable describeVsStreamsPublishListCallable(const Model::DescribeVsStreamsPublishListRequest& request) const;
DescribeVsTopDomainsByFlowOutcome describeVsTopDomainsByFlow(const Model::DescribeVsTopDomainsByFlowRequest &request)const;
void describeVsTopDomainsByFlowAsync(const Model::DescribeVsTopDomainsByFlowRequest& request, const DescribeVsTopDomainsByFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsTopDomainsByFlowOutcomeCallable describeVsTopDomainsByFlowCallable(const Model::DescribeVsTopDomainsByFlowRequest& request) const;
DescribeVsUpPeakPublishStreamDataOutcome describeVsUpPeakPublishStreamData(const Model::DescribeVsUpPeakPublishStreamDataRequest &request)const;
void describeVsUpPeakPublishStreamDataAsync(const Model::DescribeVsUpPeakPublishStreamDataRequest& request, const DescribeVsUpPeakPublishStreamDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsUpPeakPublishStreamDataOutcomeCallable describeVsUpPeakPublishStreamDataCallable(const Model::DescribeVsUpPeakPublishStreamDataRequest& request) const;
DescribeVsUserResourcePackageOutcome describeVsUserResourcePackage(const Model::DescribeVsUserResourcePackageRequest &request)const;
void describeVsUserResourcePackageAsync(const Model::DescribeVsUserResourcePackageRequest& request, const DescribeVsUserResourcePackageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeVsUserResourcePackageOutcomeCallable describeVsUserResourcePackageCallable(const Model::DescribeVsUserResourcePackageRequest& request) const;
ForbidVsStreamOutcome forbidVsStream(const Model::ForbidVsStreamRequest &request)const;
void forbidVsStreamAsync(const Model::ForbidVsStreamRequest& request, const ForbidVsStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ForbidVsStreamOutcomeCallable forbidVsStreamCallable(const Model::ForbidVsStreamRequest& request) const;
GotoPresetOutcome gotoPreset(const Model::GotoPresetRequest &request)const;
void gotoPresetAsync(const Model::GotoPresetRequest& request, const GotoPresetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GotoPresetOutcomeCallable gotoPresetCallable(const Model::GotoPresetRequest& request) const;
ModifyDeviceOutcome modifyDevice(const Model::ModifyDeviceRequest &request)const;
void modifyDeviceAsync(const Model::ModifyDeviceRequest& request, const ModifyDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDeviceOutcomeCallable modifyDeviceCallable(const Model::ModifyDeviceRequest& request) const;
ModifyDeviceAlarmOutcome modifyDeviceAlarm(const Model::ModifyDeviceAlarmRequest &request)const;
void modifyDeviceAlarmAsync(const Model::ModifyDeviceAlarmRequest& request, const ModifyDeviceAlarmAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDeviceAlarmOutcomeCallable modifyDeviceAlarmCallable(const Model::ModifyDeviceAlarmRequest& request) const;
ModifyDeviceCaptureOutcome modifyDeviceCapture(const Model::ModifyDeviceCaptureRequest &request)const;
void modifyDeviceCaptureAsync(const Model::ModifyDeviceCaptureRequest& request, const ModifyDeviceCaptureAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDeviceCaptureOutcomeCallable modifyDeviceCaptureCallable(const Model::ModifyDeviceCaptureRequest& request) const;
ModifyDeviceChannelsOutcome modifyDeviceChannels(const Model::ModifyDeviceChannelsRequest &request)const;
void modifyDeviceChannelsAsync(const Model::ModifyDeviceChannelsRequest& request, const ModifyDeviceChannelsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDeviceChannelsOutcomeCallable modifyDeviceChannelsCallable(const Model::ModifyDeviceChannelsRequest& request) const;
ModifyDirectoryOutcome modifyDirectory(const Model::ModifyDirectoryRequest &request)const;
void modifyDirectoryAsync(const Model::ModifyDirectoryRequest& request, const ModifyDirectoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDirectoryOutcomeCallable modifyDirectoryCallable(const Model::ModifyDirectoryRequest& request) const;
ModifyGroupOutcome modifyGroup(const Model::ModifyGroupRequest &request)const;
void modifyGroupAsync(const Model::ModifyGroupRequest& request, const ModifyGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyGroupOutcomeCallable modifyGroupCallable(const Model::ModifyGroupRequest& request) const;
ModifyParentPlatformOutcome modifyParentPlatform(const Model::ModifyParentPlatformRequest &request)const;
void modifyParentPlatformAsync(const Model::ModifyParentPlatformRequest& request, const ModifyParentPlatformAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyParentPlatformOutcomeCallable modifyParentPlatformCallable(const Model::ModifyParentPlatformRequest& request) const;
ModifyTemplateOutcome modifyTemplate(const Model::ModifyTemplateRequest &request)const;
void modifyTemplateAsync(const Model::ModifyTemplateRequest& request, const ModifyTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyTemplateOutcomeCallable modifyTemplateCallable(const Model::ModifyTemplateRequest& request) const;
ResumeVsStreamOutcome resumeVsStream(const Model::ResumeVsStreamRequest &request)const;
void resumeVsStreamAsync(const Model::ResumeVsStreamRequest& request, const ResumeVsStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ResumeVsStreamOutcomeCallable resumeVsStreamCallable(const Model::ResumeVsStreamRequest& request) const;
SetPresetOutcome setPreset(const Model::SetPresetRequest &request)const;
void setPresetAsync(const Model::SetPresetRequest& request, const SetPresetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetPresetOutcomeCallable setPresetCallable(const Model::SetPresetRequest& request) const;
SetVsDomainCertificateOutcome setVsDomainCertificate(const Model::SetVsDomainCertificateRequest &request)const;
void setVsDomainCertificateAsync(const Model::SetVsDomainCertificateRequest& request, const SetVsDomainCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetVsDomainCertificateOutcomeCallable setVsDomainCertificateCallable(const Model::SetVsDomainCertificateRequest& request) const;
SetVsStreamsNotifyUrlConfigOutcome setVsStreamsNotifyUrlConfig(const Model::SetVsStreamsNotifyUrlConfigRequest &request)const;
void setVsStreamsNotifyUrlConfigAsync(const Model::SetVsStreamsNotifyUrlConfigRequest& request, const SetVsStreamsNotifyUrlConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetVsStreamsNotifyUrlConfigOutcomeCallable setVsStreamsNotifyUrlConfigCallable(const Model::SetVsStreamsNotifyUrlConfigRequest& request) const;
StartDeviceOutcome startDevice(const Model::StartDeviceRequest &request)const;
void startDeviceAsync(const Model::StartDeviceRequest& request, const StartDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartDeviceOutcomeCallable startDeviceCallable(const Model::StartDeviceRequest& request) const;
StartParentPlatformOutcome startParentPlatform(const Model::StartParentPlatformRequest &request)const;
void startParentPlatformAsync(const Model::StartParentPlatformRequest& request, const StartParentPlatformAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartParentPlatformOutcomeCallable startParentPlatformCallable(const Model::StartParentPlatformRequest& request) const;
StartRecordStreamOutcome startRecordStream(const Model::StartRecordStreamRequest &request)const;
void startRecordStreamAsync(const Model::StartRecordStreamRequest& request, const StartRecordStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartRecordStreamOutcomeCallable startRecordStreamCallable(const Model::StartRecordStreamRequest& request) const;
StartStreamOutcome startStream(const Model::StartStreamRequest &request)const;
void startStreamAsync(const Model::StartStreamRequest& request, const StartStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartStreamOutcomeCallable startStreamCallable(const Model::StartStreamRequest& request) const;
StartTransferStreamOutcome startTransferStream(const Model::StartTransferStreamRequest &request)const;
void startTransferStreamAsync(const Model::StartTransferStreamRequest& request, const StartTransferStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartTransferStreamOutcomeCallable startTransferStreamCallable(const Model::StartTransferStreamRequest& request) const;
StopAdjustOutcome stopAdjust(const Model::StopAdjustRequest &request)const;
void stopAdjustAsync(const Model::StopAdjustRequest& request, const StopAdjustAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopAdjustOutcomeCallable stopAdjustCallable(const Model::StopAdjustRequest& request) const;
StopDeviceOutcome stopDevice(const Model::StopDeviceRequest &request)const;
void stopDeviceAsync(const Model::StopDeviceRequest& request, const StopDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopDeviceOutcomeCallable stopDeviceCallable(const Model::StopDeviceRequest& request) const;
StopMoveOutcome stopMove(const Model::StopMoveRequest &request)const;
void stopMoveAsync(const Model::StopMoveRequest& request, const StopMoveAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopMoveOutcomeCallable stopMoveCallable(const Model::StopMoveRequest& request) const;
StopRecordStreamOutcome stopRecordStream(const Model::StopRecordStreamRequest &request)const;
void stopRecordStreamAsync(const Model::StopRecordStreamRequest& request, const StopRecordStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopRecordStreamOutcomeCallable stopRecordStreamCallable(const Model::StopRecordStreamRequest& request) const;
StopStreamOutcome stopStream(const Model::StopStreamRequest &request)const;
void stopStreamAsync(const Model::StopStreamRequest& request, const StopStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopStreamOutcomeCallable stopStreamCallable(const Model::StopStreamRequest& request) const;
StopTransferStreamOutcome stopTransferStream(const Model::StopTransferStreamRequest &request)const;
void stopTransferStreamAsync(const Model::StopTransferStreamRequest& request, const StopTransferStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopTransferStreamOutcomeCallable stopTransferStreamCallable(const Model::StopTransferStreamRequest& request) const;
SyncCatalogsOutcome syncCatalogs(const Model::SyncCatalogsRequest &request)const;
void syncCatalogsAsync(const Model::SyncCatalogsRequest& request, const SyncCatalogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SyncCatalogsOutcomeCallable syncCatalogsCallable(const Model::SyncCatalogsRequest& request) const;
UnbindDirectoryOutcome unbindDirectory(const Model::UnbindDirectoryRequest &request)const;
void unbindDirectoryAsync(const Model::UnbindDirectoryRequest& request, const UnbindDirectoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UnbindDirectoryOutcomeCallable unbindDirectoryCallable(const Model::UnbindDirectoryRequest& request) const;
UnbindParentPlatformDeviceOutcome unbindParentPlatformDevice(const Model::UnbindParentPlatformDeviceRequest &request)const;
void unbindParentPlatformDeviceAsync(const Model::UnbindParentPlatformDeviceRequest& request, const UnbindParentPlatformDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UnbindParentPlatformDeviceOutcomeCallable unbindParentPlatformDeviceCallable(const Model::UnbindParentPlatformDeviceRequest& request) const;
UnbindPurchasedDeviceOutcome unbindPurchasedDevice(const Model::UnbindPurchasedDeviceRequest &request)const;
void unbindPurchasedDeviceAsync(const Model::UnbindPurchasedDeviceRequest& request, const UnbindPurchasedDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UnbindPurchasedDeviceOutcomeCallable unbindPurchasedDeviceCallable(const Model::UnbindPurchasedDeviceRequest& request) const;
UnbindTemplateOutcome unbindTemplate(const Model::UnbindTemplateRequest &request)const;
void unbindTemplateAsync(const Model::UnbindTemplateRequest& request, const UnbindTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UnbindTemplateOutcomeCallable unbindTemplateCallable(const Model::UnbindTemplateRequest& request) const;
UnlockDeviceOutcome unlockDevice(const Model::UnlockDeviceRequest &request)const;
void unlockDeviceAsync(const Model::UnlockDeviceRequest& request, const UnlockDeviceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UnlockDeviceOutcomeCallable unlockDeviceCallable(const Model::UnlockDeviceRequest& request) const;
UpdateVsPullStreamInfoConfigOutcome updateVsPullStreamInfoConfig(const Model::UpdateVsPullStreamInfoConfigRequest &request)const;
void updateVsPullStreamInfoConfigAsync(const Model::UpdateVsPullStreamInfoConfigRequest& request, const UpdateVsPullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateVsPullStreamInfoConfigOutcomeCallable updateVsPullStreamInfoConfigCallable(const Model::UpdateVsPullStreamInfoConfigRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_VS_VSCLIENT_H_

View File

@@ -0,0 +1,32 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_VSEXPORT_H_
#define ALIBABACLOUD_VS_VSEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_VS_LIBRARY)
# define ALIBABACLOUD_VS_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_VS_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_VS_EXPORT
#endif
#endif // !ALIBABACLOUD_VS_VSEXPORT_H_

View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_ADDVSPULLSTREAMINFOCONFIGREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_ADDVSPULLSTREAMINFOCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT AddVsPullStreamInfoConfigRequest : public RpcServiceRequest
{
public:
AddVsPullStreamInfoConfigRequest();
~AddVsPullStreamInfoConfigRequest();
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getAlways()const;
void setAlways(const std::string& always);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getSourceUrl()const;
void setSourceUrl(const std::string& sourceUrl);
private:
std::string startTime_;
std::string appName_;
std::string streamName_;
std::string showLog_;
std::string always_;
std::string domainName_;
std::string endTime_;
long ownerId_;
std::string sourceUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_ADDVSPULLSTREAMINFOCONFIGREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHBINDDIRECTORIESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHBINDDIRECTORIESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchBindDirectoriesRequest : public RpcServiceRequest
{
public:
BatchBindDirectoriesRequest();
~BatchBindDirectoriesRequest();
std::string getDirectoryId()const;
void setDirectoryId(const std::string& directoryId);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDeviceId()const;
void setDeviceId(const std::string& deviceId);
private:
std::string directoryId_;
std::string showLog_;
long ownerId_;
std::string deviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHBINDDIRECTORIESREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHBINDPARENTPLATFORMDEVICESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHBINDPARENTPLATFORMDEVICESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchBindParentPlatformDevicesRequest : public RpcServiceRequest
{
public:
BatchBindParentPlatformDevicesRequest();
~BatchBindParentPlatformDevicesRequest();
std::string getParentPlatformId()const;
void setParentPlatformId(const std::string& parentPlatformId);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDeviceId()const;
void setDeviceId(const std::string& deviceId);
private:
std::string parentPlatformId_;
std::string showLog_;
long ownerId_;
std::string deviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHBINDPARENTPLATFORMDEVICESREQUEST_H_

View File

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

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHBINDPURCHASEDDEVICESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHBINDPURCHASEDDEVICESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchBindPurchasedDevicesRequest : public RpcServiceRequest
{
public:
BatchBindPurchasedDevicesRequest();
~BatchBindPurchasedDevicesRequest();
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDeviceId()const;
void setDeviceId(const std::string& deviceId);
std::string getRegion()const;
void setRegion(const std::string& region);
private:
std::string showLog_;
std::string groupId_;
long ownerId_;
std::string deviceId_;
std::string region_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHBINDPURCHASEDDEVICESREQUEST_H_

View File

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

View File

@@ -0,0 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHBINDTEMPLATEREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHBINDTEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchBindTemplateRequest : public RpcServiceRequest
{
public:
BatchBindTemplateRequest();
~BatchBindTemplateRequest();
bool getReplace()const;
void setReplace(bool replace);
std::string getInstanceType()const;
void setInstanceType(const std::string& instanceType);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
bool getApplyAll()const;
void setApplyAll(bool applyAll);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
private:
bool replace_;
std::string instanceType_;
std::string showLog_;
bool applyAll_;
long ownerId_;
std::string templateId_;
std::string instanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHBINDTEMPLATEREQUEST_H_

View File

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

View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHBINDTEMPLATESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHBINDTEMPLATESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchBindTemplatesRequest : public RpcServiceRequest
{
public:
BatchBindTemplatesRequest();
~BatchBindTemplatesRequest();
bool getReplace()const;
void setReplace(bool replace);
std::string getTemplateType()const;
void setTemplateType(const std::string& templateType);
std::string getInstanceType()const;
void setInstanceType(const std::string& instanceType);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
bool getApplyAll()const;
void setApplyAll(bool applyAll);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
private:
bool replace_;
std::string templateType_;
std::string instanceType_;
std::string showLog_;
bool applyAll_;
long ownerId_;
std::string templateId_;
std::string instanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHBINDTEMPLATESREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHDELETEDEVICESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHDELETEDEVICESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchDeleteDevicesRequest : public RpcServiceRequest
{
public:
BatchDeleteDevicesRequest();
~BatchDeleteDevicesRequest();
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHDELETEDEVICESREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHDELETEVSDOMAINCONFIGSREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHDELETEVSDOMAINCONFIGSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchDeleteVsDomainConfigsRequest : public RpcServiceRequest
{
public:
BatchDeleteVsDomainConfigsRequest();
~BatchDeleteVsDomainConfigsRequest();
std::string getFunctionNames()const;
void setFunctionNames(const std::string& functionNames);
std::string getDomainNames()const;
void setDomainNames(const std::string& domainNames);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string functionNames_;
std::string domainNames_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHDELETEVSDOMAINCONFIGSREQUEST_H_

View File

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

View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHFORBIDVSSTREAMREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHFORBIDVSSTREAMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchForbidVsStreamRequest : public RpcServiceRequest
{
public:
BatchForbidVsStreamRequest();
~BatchForbidVsStreamRequest();
std::string getChannel()const;
void setChannel(const std::string& channel);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getControlStreamAction()const;
void setControlStreamAction(const std::string& controlStreamAction);
std::string getResumeTime()const;
void setResumeTime(const std::string& resumeTime);
std::string getLiveStreamType()const;
void setLiveStreamType(const std::string& liveStreamType);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getOneshot()const;
void setOneshot(const std::string& oneshot);
private:
std::string channel_;
std::string showLog_;
std::string controlStreamAction_;
std::string resumeTime_;
std::string liveStreamType_;
std::string domainName_;
long ownerId_;
std::string oneshot_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHFORBIDVSSTREAMREQUEST_H_

View File

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

View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHRESUMEVSSTREAMREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHRESUMEVSSTREAMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchResumeVsStreamRequest : public RpcServiceRequest
{
public:
BatchResumeVsStreamRequest();
~BatchResumeVsStreamRequest();
std::string getChannel()const;
void setChannel(const std::string& channel);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getControlStreamAction()const;
void setControlStreamAction(const std::string& controlStreamAction);
std::string getLiveStreamType()const;
void setLiveStreamType(const std::string& liveStreamType);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string channel_;
std::string showLog_;
std::string controlStreamAction_;
std::string liveStreamType_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHRESUMEVSSTREAMREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHSETVSDOMAINCONFIGSREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHSETVSDOMAINCONFIGSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchSetVsDomainConfigsRequest : public RpcServiceRequest
{
public:
BatchSetVsDomainConfigsRequest();
~BatchSetVsDomainConfigsRequest();
std::string getFunctions()const;
void setFunctions(const std::string& functions);
std::string getDomainNames()const;
void setDomainNames(const std::string& domainNames);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string functions_;
std::string domainNames_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHSETVSDOMAINCONFIGSREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHSTARTDEVICESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHSTARTDEVICESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchStartDevicesRequest : public RpcServiceRequest
{
public:
BatchStartDevicesRequest();
~BatchStartDevicesRequest();
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHSTARTDEVICESREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHSTARTSTREAMSREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHSTARTSTREAMSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchStartStreamsRequest : public RpcServiceRequest
{
public:
BatchStartStreamsRequest();
~BatchStartStreamsRequest();
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHSTARTSTREAMSREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHSTOPDEVICESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHSTOPDEVICESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchStopDevicesRequest : public RpcServiceRequest
{
public:
BatchStopDevicesRequest();
~BatchStopDevicesRequest();
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string startTime_;
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHSTOPDEVICESREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHSTOPSTREAMSREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHSTOPSTREAMSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchStopStreamsRequest : public RpcServiceRequest
{
public:
BatchStopStreamsRequest();
~BatchStopStreamsRequest();
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string startTime_;
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHSTOPSTREAMSREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHUNBINDDIRECTORIESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHUNBINDDIRECTORIESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchUnbindDirectoriesRequest : public RpcServiceRequest
{
public:
BatchUnbindDirectoriesRequest();
~BatchUnbindDirectoriesRequest();
std::string getDirectoryId()const;
void setDirectoryId(const std::string& directoryId);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDeviceId()const;
void setDeviceId(const std::string& deviceId);
private:
std::string directoryId_;
std::string showLog_;
long ownerId_;
std::string deviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHUNBINDDIRECTORIESREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHUNBINDPARENTPLATFORMDEVICESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHUNBINDPARENTPLATFORMDEVICESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchUnbindParentPlatformDevicesRequest : public RpcServiceRequest
{
public:
BatchUnbindParentPlatformDevicesRequest();
~BatchUnbindParentPlatformDevicesRequest();
std::string getParentPlatformId()const;
void setParentPlatformId(const std::string& parentPlatformId);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDeviceId()const;
void setDeviceId(const std::string& deviceId);
private:
std::string parentPlatformId_;
std::string showLog_;
long ownerId_;
std::string deviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHUNBINDPARENTPLATFORMDEVICESREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHUNBINDPURCHASEDDEVICESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHUNBINDPURCHASEDDEVICESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchUnbindPurchasedDevicesRequest : public RpcServiceRequest
{
public:
BatchUnbindPurchasedDevicesRequest();
~BatchUnbindPurchasedDevicesRequest();
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDeviceId()const;
void setDeviceId(const std::string& deviceId);
private:
std::string showLog_;
long ownerId_;
std::string deviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHUNBINDPURCHASEDDEVICESREQUEST_H_

View File

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

View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHUNBINDTEMPLATEREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHUNBINDTEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchUnbindTemplateRequest : public RpcServiceRequest
{
public:
BatchUnbindTemplateRequest();
~BatchUnbindTemplateRequest();
std::string getTemplateType()const;
void setTemplateType(const std::string& templateType);
std::string getInstanceType()const;
void setInstanceType(const std::string& instanceType);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
private:
std::string templateType_;
std::string instanceType_;
std::string showLog_;
long ownerId_;
std::string templateId_;
std::string instanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHUNBINDTEMPLATEREQUEST_H_

View File

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

View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BATCHUNBINDTEMPLATESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BATCHUNBINDTEMPLATESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BatchUnbindTemplatesRequest : public RpcServiceRequest
{
public:
BatchUnbindTemplatesRequest();
~BatchUnbindTemplatesRequest();
std::string getTemplateType()const;
void setTemplateType(const std::string& templateType);
std::string getInstanceType()const;
void setInstanceType(const std::string& instanceType);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
private:
std::string templateType_;
std::string instanceType_;
std::string showLog_;
long ownerId_;
std::string templateId_;
std::string instanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BATCHUNBINDTEMPLATESREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BINDDIRECTORYREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BINDDIRECTORYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BindDirectoryRequest : public RpcServiceRequest
{
public:
BindDirectoryRequest();
~BindDirectoryRequest();
std::string getDirectoryId()const;
void setDirectoryId(const std::string& directoryId);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDeviceId()const;
void setDeviceId(const std::string& deviceId);
private:
std::string directoryId_;
std::string showLog_;
long ownerId_;
std::string deviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BINDDIRECTORYREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BINDPARENTPLATFORMDEVICEREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BINDPARENTPLATFORMDEVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BindParentPlatformDeviceRequest : public RpcServiceRequest
{
public:
BindParentPlatformDeviceRequest();
~BindParentPlatformDeviceRequest();
std::string getParentPlatformId()const;
void setParentPlatformId(const std::string& parentPlatformId);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDeviceId()const;
void setDeviceId(const std::string& deviceId);
private:
std::string parentPlatformId_;
std::string showLog_;
long ownerId_;
std::string deviceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BINDPARENTPLATFORMDEVICEREQUEST_H_

View File

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

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BINDPURCHASEDDEVICEREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BINDPURCHASEDDEVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BindPurchasedDeviceRequest : public RpcServiceRequest
{
public:
BindPurchasedDeviceRequest();
~BindPurchasedDeviceRequest();
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getDeviceId()const;
void setDeviceId(const std::string& deviceId);
std::string getRegion()const;
void setRegion(const std::string& region);
private:
std::string showLog_;
std::string groupId_;
long ownerId_;
std::string deviceId_;
std::string region_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BINDPURCHASEDDEVICEREQUEST_H_

View File

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

View File

@@ -0,0 +1,69 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_BINDTEMPLATEREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_BINDTEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT BindTemplateRequest : public RpcServiceRequest
{
public:
BindTemplateRequest();
~BindTemplateRequest();
bool getReplace()const;
void setReplace(bool replace);
std::string getTemplateType()const;
void setTemplateType(const std::string& templateType);
std::string getInstanceType()const;
void setInstanceType(const std::string& instanceType);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
bool getApplyAll()const;
void setApplyAll(bool applyAll);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTemplateId()const;
void setTemplateId(const std::string& templateId);
std::string getInstanceId()const;
void setInstanceId(const std::string& instanceId);
private:
bool replace_;
std::string templateType_;
std::string instanceType_;
std::string showLog_;
bool applyAll_;
long ownerId_;
std::string templateId_;
std::string instanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_BINDTEMPLATEREQUEST_H_

View File

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

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_CONTINUOUSADJUSTREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_CONTINUOUSADJUSTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT ContinuousAdjustRequest : public RpcServiceRequest
{
public:
ContinuousAdjustRequest();
~ContinuousAdjustRequest();
std::string getFocus()const;
void setFocus(const std::string& focus);
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getIris()const;
void setIris(const std::string& iris);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string focus_;
std::string id_;
std::string showLog_;
std::string iris_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_CONTINUOUSADJUSTREQUEST_H_

View File

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

View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_CONTINUOUSMOVEREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_CONTINUOUSMOVEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT ContinuousMoveRequest : public RpcServiceRequest
{
public:
ContinuousMoveRequest();
~ContinuousMoveRequest();
std::string getTilt()const;
void setTilt(const std::string& tilt);
std::string getId()const;
void setId(const std::string& id);
std::string getPan()const;
void setPan(const std::string& pan);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getZoom()const;
void setZoom(const std::string& zoom);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string tilt_;
std::string id_;
std::string pan_;
std::string showLog_;
std::string zoom_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_CONTINUOUSMOVEREQUEST_H_

View File

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

View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_CREATEDEVICEALARMREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_CREATEDEVICEALARMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT CreateDeviceAlarmRequest : public RpcServiceRequest
{
public:
CreateDeviceAlarmRequest();
~CreateDeviceAlarmRequest();
long getStartTime()const;
void setStartTime(long startTime);
int getAlarm()const;
void setAlarm(int alarm);
std::string getId()const;
void setId(const std::string& id);
int getObjectType()const;
void setObjectType(int objectType);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getEndTime()const;
void setEndTime(long endTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
int getSubAlarm()const;
void setSubAlarm(int subAlarm);
long getExpire()const;
void setExpire(long expire);
int getChannelId()const;
void setChannelId(int channelId);
private:
long startTime_;
int alarm_;
std::string id_;
int objectType_;
std::string showLog_;
long endTime_;
long ownerId_;
int subAlarm_;
long expire_;
int channelId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_CREATEDEVICEALARMREQUEST_H_

View File

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

View File

@@ -0,0 +1,114 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_VS_MODEL_CREATEDEVICEREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_CREATEDEVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT CreateDeviceRequest : public RpcServiceRequest
{
public:
CreateDeviceRequest();
~CreateDeviceRequest();
std::string getGbId()const;
void setGbId(const std::string& gbId);
std::string getLatitude()const;
void setLatitude(const std::string& latitude);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getType()const;
void setType(const std::string& type);
bool getAutoStart()const;
void setAutoStart(bool autoStart);
std::string getParentId()const;
void setParentId(const std::string& parentId);
std::string getPassword()const;
void setPassword(const std::string& password);
std::string getVendor()const;
void setVendor(const std::string& vendor);
std::string getAlarmMethod()const;
void setAlarmMethod(const std::string& alarmMethod);
std::string getDirectoryId()const;
void setDirectoryId(const std::string& directoryId);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getLongitude()const;
void setLongitude(const std::string& longitude);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
std::string getIp()const;
void setIp(const std::string& ip);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getParams()const;
void setParams(const std::string& params);
std::string getUrl()const;
void setUrl(const std::string& url);
long getPort()const;
void setPort(long port);
std::string getName()const;
void setName(const std::string& name);
long getPosInterval()const;
void setPosInterval(long posInterval);
std::string getDsn()const;
void setDsn(const std::string& dsn);
std::string getUsername()const;
void setUsername(const std::string& username);
bool getAutoPos()const;
void setAutoPos(bool autoPos);
private:
std::string gbId_;
std::string latitude_;
std::string description_;
std::string type_;
bool autoStart_;
std::string parentId_;
std::string password_;
std::string vendor_;
std::string alarmMethod_;
std::string directoryId_;
std::string showLog_;
std::string longitude_;
std::string groupId_;
std::string ip_;
long ownerId_;
std::string params_;
std::string url_;
long port_;
std::string name_;
long posInterval_;
std::string dsn_;
std::string username_;
bool autoPos_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_CREATEDEVICEREQUEST_H_

View File

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

View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_CREATEDIRECTORYREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_CREATEDIRECTORYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT CreateDirectoryRequest : public RpcServiceRequest
{
public:
CreateDirectoryRequest();
~CreateDirectoryRequest();
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getParentId()const;
void setParentId(const std::string& parentId);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getName()const;
void setName(const std::string& name);
private:
std::string description_;
std::string parentId_;
std::string showLog_;
std::string groupId_;
long ownerId_;
std::string name_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_CREATEDIRECTORYREQUEST_H_

View File

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

View File

@@ -0,0 +1,96 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_VS_MODEL_CREATEGROUPREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_CREATEGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT CreateGroupRequest : public RpcServiceRequest
{
public:
CreateGroupRequest();
~CreateGroupRequest();
int getCaptureVideo()const;
void setCaptureVideo(int captureVideo);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getCaptureOssPath()const;
void setCaptureOssPath(const std::string& captureOssPath);
std::string getPushDomain()const;
void setPushDomain(const std::string& pushDomain);
int getCaptureImage()const;
void setCaptureImage(int captureImage);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getApp()const;
void setApp(const std::string& app);
std::string getPlayDomain()const;
void setPlayDomain(const std::string& playDomain);
std::string getOutProtocol()const;
void setOutProtocol(const std::string& outProtocol);
int getCaptureInterval()const;
void setCaptureInterval(int captureInterval);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getInProtocol()const;
void setInProtocol(const std::string& inProtocol);
bool getLazyPull()const;
void setLazyPull(bool lazyPull);
std::string getName()const;
void setName(const std::string& name);
std::string getCallback()const;
void setCallback(const std::string& callback);
std::string getRegion()const;
void setRegion(const std::string& region);
std::string getCaptureOssBucket()const;
void setCaptureOssBucket(const std::string& captureOssBucket);
private:
int captureVideo_;
std::string description_;
std::string captureOssPath_;
std::string pushDomain_;
int captureImage_;
std::string showLog_;
std::string app_;
std::string playDomain_;
std::string outProtocol_;
int captureInterval_;
long ownerId_;
std::string inProtocol_;
bool lazyPull_;
std::string name_;
std::string callback_;
std::string region_;
std::string captureOssBucket_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_CREATEGROUPREQUEST_H_

View File

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

View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_CREATEPARENTPLATFORMREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_CREATEPARENTPLATFORMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT CreateParentPlatformRequest : public RpcServiceRequest
{
public:
CreateParentPlatformRequest();
~CreateParentPlatformRequest();
std::string getGbId()const;
void setGbId(const std::string& gbId);
bool getClientAuth()const;
void setClientAuth(bool clientAuth);
std::string getDescription()const;
void setDescription(const std::string& description);
bool getAutoStart()const;
void setAutoStart(bool autoStart);
std::string getProtocol()const;
void setProtocol(const std::string& protocol);
std::string getClientPassword()const;
void setClientPassword(const std::string& clientPassword);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getIp()const;
void setIp(const std::string& ip);
long getOwnerId()const;
void setOwnerId(long ownerId);
long getPort()const;
void setPort(long port);
std::string getName()const;
void setName(const std::string& name);
std::string getClientUsername()const;
void setClientUsername(const std::string& clientUsername);
private:
std::string gbId_;
bool clientAuth_;
std::string description_;
bool autoStart_;
std::string protocol_;
std::string clientPassword_;
std::string showLog_;
std::string ip_;
long ownerId_;
long port_;
std::string name_;
std::string clientUsername_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_CREATEPARENTPLATFORMREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_CREATESTREAMSNAPSHOTREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_CREATESTREAMSNAPSHOTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT CreateStreamSnapshotRequest : public RpcServiceRequest
{
public:
CreateStreamSnapshotRequest();
~CreateStreamSnapshotRequest();
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getLocation()const;
void setLocation(const std::string& location);
private:
std::string id_;
std::string showLog_;
long ownerId_;
std::string location_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_CREATESTREAMSNAPSHOTREQUEST_H_

View File

@@ -0,0 +1,67 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_CREATESTREAMSNAPSHOTRESULT_H_
#define ALIBABACLOUD_VS_MODEL_CREATESTREAMSNAPSHOTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT CreateStreamSnapshotResult : public ServiceResult
{
public:
CreateStreamSnapshotResult();
explicit CreateStreamSnapshotResult(const std::string &payload);
~CreateStreamSnapshotResult();
std::string getFormat()const;
std::string getOssEndpoint()const;
std::string getOssBucket()const;
std::string getOssObject()const;
long getHeight()const;
std::string getId()const;
long getWidth()const;
long getTimestamp()const;
std::string getUrl()const;
protected:
void parse(const std::string &payload);
private:
std::string format_;
std::string ossEndpoint_;
std::string ossBucket_;
std::string ossObject_;
long height_;
std::string id_;
long width_;
long timestamp_;
std::string url_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_CREATESTREAMSNAPSHOTRESULT_H_

View File

@@ -0,0 +1,117 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_CREATETEMPLATEREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_CREATETEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT CreateTemplateRequest : public RpcServiceRequest
{
public:
CreateTemplateRequest();
~CreateTemplateRequest();
std::string getHlsTs()const;
void setHlsTs(const std::string& hlsTs);
std::string getOssEndpoint()const;
void setOssEndpoint(const std::string& ossEndpoint);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getOssFilePrefix()const;
void setOssFilePrefix(const std::string& ossFilePrefix);
std::string getJpgOverwrite()const;
void setJpgOverwrite(const std::string& jpgOverwrite);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getType()const;
void setType(const std::string& type);
std::string getJpgOnDemand()const;
void setJpgOnDemand(const std::string& jpgOnDemand);
long getRetention()const;
void setRetention(long retention);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getHlsM3u8()const;
void setHlsM3u8(const std::string& hlsM3u8);
std::string getOssBucket()const;
void setOssBucket(const std::string& ossBucket);
std::string getTransConfigsJSON()const;
void setTransConfigsJSON(const std::string& transConfigsJSON);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getTrigger()const;
void setTrigger(const std::string& trigger);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getJpgSequence()const;
void setJpgSequence(const std::string& jpgSequence);
std::string getMp4()const;
void setMp4(const std::string& mp4);
std::string getFlv()const;
void setFlv(const std::string& flv);
std::string getName()const;
void setName(const std::string& name);
std::string getCallback()const;
void setCallback(const std::string& callback);
long getInterval()const;
void setInterval(long interval);
std::string getFileFormat()const;
void setFileFormat(const std::string& fileFormat);
std::string getRegion()const;
void setRegion(const std::string& region);
private:
std::string hlsTs_;
std::string ossEndpoint_;
std::string description_;
std::string ossFilePrefix_;
std::string jpgOverwrite_;
std::string startTime_;
std::string type_;
std::string jpgOnDemand_;
long retention_;
std::string showLog_;
std::string hlsM3u8_;
std::string ossBucket_;
std::string transConfigsJSON_;
std::string endTime_;
std::string trigger_;
long ownerId_;
std::string jpgSequence_;
std::string mp4_;
std::string flv_;
std::string name_;
std::string callback_;
long interval_;
std::string fileFormat_;
std::string region_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_CREATETEMPLATEREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DELETEDEVICEREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DELETEDEVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DeleteDeviceRequest : public RpcServiceRequest
{
public:
DeleteDeviceRequest();
~DeleteDeviceRequest();
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DELETEDEVICEREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DELETEDIRECTORYREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DELETEDIRECTORYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DeleteDirectoryRequest : public RpcServiceRequest
{
public:
DeleteDirectoryRequest();
~DeleteDirectoryRequest();
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DELETEDIRECTORYREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DELETEGROUPREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DELETEGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DeleteGroupRequest : public RpcServiceRequest
{
public:
DeleteGroupRequest();
~DeleteGroupRequest();
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DELETEGROUPREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DELETEPARENTPLATFORMREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DELETEPARENTPLATFORMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DeleteParentPlatformRequest : public RpcServiceRequest
{
public:
DeleteParentPlatformRequest();
~DeleteParentPlatformRequest();
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DELETEPARENTPLATFORMREQUEST_H_

View File

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

View File

@@ -0,0 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DELETEPRESETREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DELETEPRESETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DeletePresetRequest : public RpcServiceRequest
{
public:
DeletePresetRequest();
~DeletePresetRequest();
std::string getId()const;
void setId(const std::string& id);
std::string getPresetId()const;
void setPresetId(const std::string& presetId);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string id_;
std::string presetId_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DELETEPRESETREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DELETETEMPLATEREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DELETETEMPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DeleteTemplateRequest : public RpcServiceRequest
{
public:
DeleteTemplateRequest();
~DeleteTemplateRequest();
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DELETETEMPLATEREQUEST_H_

View File

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

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DELETEVSPULLSTREAMINFOCONFIGREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DELETEVSPULLSTREAMINFOCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DeleteVsPullStreamInfoConfigRequest : public RpcServiceRequest
{
public:
DeleteVsPullStreamInfoConfigRequest();
~DeleteVsPullStreamInfoConfigRequest();
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string appName_;
std::string streamName_;
std::string showLog_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DELETEVSPULLSTREAMINFOCONFIGREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DELETEVSSTREAMSNOTIFYURLCONFIGREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DELETEVSSTREAMSNOTIFYURLCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DeleteVsStreamsNotifyUrlConfigRequest : public RpcServiceRequest
{
public:
DeleteVsStreamsNotifyUrlConfigRequest();
~DeleteVsStreamsNotifyUrlConfigRequest();
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string showLog_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DELETEVSSTREAMSNOTIFYURLCONFIGREQUEST_H_

View File

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

View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DESCRIBEACCOUNTSTATREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DESCRIBEACCOUNTSTATREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DescribeAccountStatRequest : public RpcServiceRequest
{
public:
DescribeAccountStatRequest();
~DescribeAccountStatRequest();
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DESCRIBEACCOUNTSTATREQUEST_H_

View File

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

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICECHANNELSREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICECHANNELSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DescribeDeviceChannelsRequest : public RpcServiceRequest
{
public:
DescribeDeviceChannelsRequest();
~DescribeDeviceChannelsRequest();
long getPageNum()const;
void setPageNum(long pageNum);
long getPageSize()const;
void setPageSize(long pageSize);
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long pageNum_;
long pageSize_;
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICECHANNELSREQUEST_H_

View File

@@ -0,0 +1,70 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICECHANNELSRESULT_H_
#define ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICECHANNELSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DescribeDeviceChannelsResult : public ServiceResult
{
public:
struct Channel
{
std::string streamId;
std::string deviceId;
std::string gbId;
std::string params;
std::string deviceStatus;
std::string streamStatus;
long channelId;
std::string name;
};
DescribeDeviceChannelsResult();
explicit DescribeDeviceChannelsResult(const std::string &payload);
~DescribeDeviceChannelsResult();
long getTotalCount()const;
long getPageSize()const;
long getPageNum()const;
long getPageCount()const;
std::vector<Channel> getChannels()const;
protected:
void parse(const std::string &payload);
private:
long totalCount_;
long pageSize_;
long pageNum_;
long pageCount_;
std::vector<Channel> channels_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICECHANNELSRESULT_H_

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICEGATEWAYREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICEGATEWAYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DescribeDeviceGatewayRequest : public RpcServiceRequest
{
public:
DescribeDeviceGatewayRequest();
~DescribeDeviceGatewayRequest();
std::string getClientIp()const;
void setClientIp(const std::string& clientIp);
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
long getExpire()const;
void setExpire(long expire);
private:
std::string clientIp_;
std::string id_;
std::string showLog_;
long ownerId_;
long expire_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICEGATEWAYREQUEST_H_

View File

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

View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICEREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DescribeDeviceRequest : public RpcServiceRequest
{
public:
DescribeDeviceRequest();
~DescribeDeviceRequest();
bool getIncludeDirectory()const;
void setIncludeDirectory(bool includeDirectory);
bool getIncludeStats()const;
void setIncludeStats(bool includeStats);
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
bool includeDirectory_;
bool includeStats_;
std::string id_;
std::string showLog_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICEREQUEST_H_

View File

@@ -0,0 +1,126 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICERESULT_H_
#define ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DescribeDeviceResult : public ServiceResult
{
public:
struct Stats
{
long offlineNum;
long failedNum;
long streamNum;
long channelNum;
long onlineNum;
};
struct Directory
{
std::string parentId;
std::string description;
std::string createdTime;
std::string id;
std::string name;
std::string groupId;
};
DescribeDeviceResult();
explicit DescribeDeviceResult(const std::string &payload);
~DescribeDeviceResult();
std::string getAlarmMethod()const;
std::string getDescription()const;
std::string getCreatedTime()const;
std::string getIp()const;
long getPort()const;
std::string getChannelSyncTime()const;
std::string getLatitude()const;
std::string getUrl()const;
std::string getName()const;
std::string getGbId()const;
std::string getProtocol()const;
bool getAutoStart()const;
std::string getDsn()const;
Directory getDirectory()const;
std::string getPassword()const;
std::string getParentId()const;
std::string getStatus()const;
bool getEnabled()const;
std::string getParams()const;
std::string getVendor()const;
std::string getLongitude()const;
std::string getRegisteredTime()const;
std::string getGroupId()const;
long getPosInterval()const;
std::string getType()const;
std::string getDirectoryId()const;
std::string getUsername()const;
bool getAutoPos()const;
Stats getStats()const;
std::string getId()const;
protected:
void parse(const std::string &payload);
private:
std::string alarmMethod_;
std::string description_;
std::string createdTime_;
std::string ip_;
long port_;
std::string channelSyncTime_;
std::string latitude_;
std::string url_;
std::string name_;
std::string gbId_;
std::string protocol_;
bool autoStart_;
std::string dsn_;
Directory directory_;
std::string password_;
std::string parentId_;
std::string status_;
bool enabled_;
std::string params_;
std::string vendor_;
std::string longitude_;
std::string registeredTime_;
std::string groupId_;
long posInterval_;
std::string type_;
std::string directoryId_;
std::string username_;
bool autoPos_;
Stats stats_;
std::string id_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICERESULT_H_

View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICEURLREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICEURLREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DescribeDeviceURLRequest : public RpcServiceRequest
{
public:
DescribeDeviceURLRequest();
~DescribeDeviceURLRequest();
bool getAuth()const;
void setAuth(bool auth);
std::string getType()const;
void setType(const std::string& type);
std::string getMode()const;
void setMode(const std::string& mode);
std::string getStream()const;
void setStream(const std::string& stream);
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getOutProtocol()const;
void setOutProtocol(const std::string& outProtocol);
long getOwnerId()const;
void setOwnerId(long ownerId);
long getExpire()const;
void setExpire(long expire);
private:
bool auth_;
std::string type_;
std::string mode_;
std::string stream_;
std::string id_;
std::string showLog_;
std::string outProtocol_;
long ownerId_;
long expire_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICEURLREQUEST_H_

View File

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

View File

@@ -0,0 +1,96 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_VS_MODEL_DESCRIBEDEVICESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DescribeDevicesRequest : public RpcServiceRequest
{
public:
DescribeDevicesRequest();
~DescribeDevicesRequest();
std::string getSortDirection()const;
void setSortDirection(const std::string& sortDirection);
bool getIncludeDirectory()const;
void setIncludeDirectory(bool includeDirectory);
std::string getGbId()const;
void setGbId(const std::string& gbId);
std::string getType()const;
void setType(const std::string& type);
long getPageNum()const;
void setPageNum(long pageNum);
std::string getParentId()const;
void setParentId(const std::string& parentId);
bool getIncludeStats()const;
void setIncludeStats(bool includeStats);
std::string getVendor()const;
void setVendor(const std::string& vendor);
long getPageSize()const;
void setPageSize(long pageSize);
std::string getDirectoryId()const;
void setDirectoryId(const std::string& directoryId);
std::string getId()const;
void setId(const std::string& id);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getName()const;
void setName(const std::string& name);
std::string getSortBy()const;
void setSortBy(const std::string& sortBy);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
std::string sortDirection_;
bool includeDirectory_;
std::string gbId_;
std::string type_;
long pageNum_;
std::string parentId_;
bool includeStats_;
std::string vendor_;
long pageSize_;
std::string directoryId_;
std::string id_;
std::string showLog_;
std::string groupId_;
long ownerId_;
std::string name_;
std::string sortBy_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICESREQUEST_H_

View File

@@ -0,0 +1,109 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT 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_VS_MODEL_DESCRIBEDEVICESRESULT_H_
#define ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DescribeDevicesResult : public ServiceResult
{
public:
struct Device
{
struct Stats
{
long offlineNum;
long failedNum;
long streamNum;
long channelNum;
long onlineNum;
};
struct Directory
{
std::string parentId;
std::string description;
std::string createdTime;
std::string id;
std::string name;
std::string groupId;
};
std::string alarmMethod;
std::string description;
std::string createdTime;
std::string ip;
long port;
std::string channelSyncTime;
std::string latitude;
std::string url;
std::string name;
std::string gbId;
std::string protocol;
bool autoStart;
std::string dsn;
Directory directory;
std::string password;
std::string parentId;
std::string status;
bool enabled;
std::string params;
std::string vendor;
std::string longitude;
std::string registeredTime;
std::string groupId;
long posInterval;
std::string type;
std::string directoryId;
std::string username;
bool autoPos;
Stats stats;
std::string id;
};
DescribeDevicesResult();
explicit DescribeDevicesResult(const std::string &payload);
~DescribeDevicesResult();
long getTotalCount()const;
long getPageSize()const;
long getPageNum()const;
long getPageCount()const;
std::vector<Device> getDevices()const;
protected:
void parse(const std::string &payload);
private:
long totalCount_;
long pageSize_;
long pageNum_;
long pageCount_;
std::vector<Device> devices_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DESCRIBEDEVICESRESULT_H_

View File

@@ -0,0 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DESCRIBEDIRECTORIESREQUEST_H_
#define ALIBABACLOUD_VS_MODEL_DESCRIBEDIRECTORIESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DescribeDirectoriesRequest : public RpcServiceRequest
{
public:
DescribeDirectoriesRequest();
~DescribeDirectoriesRequest();
std::string getSortDirection()const;
void setSortDirection(const std::string& sortDirection);
long getPageNum()const;
void setPageNum(long pageNum);
bool getNoPagination()const;
void setNoPagination(bool noPagination);
std::string getParentId()const;
void setParentId(const std::string& parentId);
long getPageSize()const;
void setPageSize(long pageSize);
std::string getShowLog()const;
void setShowLog(const std::string& showLog);
std::string getGroupId()const;
void setGroupId(const std::string& groupId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getSortBy()const;
void setSortBy(const std::string& sortBy);
private:
std::string sortDirection_;
long pageNum_;
bool noPagination_;
std::string parentId_;
long pageSize_;
std::string showLog_;
std::string groupId_;
long ownerId_;
std::string sortBy_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DESCRIBEDIRECTORIESREQUEST_H_

View File

@@ -0,0 +1,68 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_VS_MODEL_DESCRIBEDIRECTORIESRESULT_H_
#define ALIBABACLOUD_VS_MODEL_DESCRIBEDIRECTORIESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/vs/VsExport.h>
namespace AlibabaCloud
{
namespace Vs
{
namespace Model
{
class ALIBABACLOUD_VS_EXPORT DescribeDirectoriesResult : public ServiceResult
{
public:
struct Directory
{
std::string parentId;
std::string description;
std::string createdTime;
std::string id;
std::string name;
std::string groupId;
};
DescribeDirectoriesResult();
explicit DescribeDirectoriesResult(const std::string &payload);
~DescribeDirectoriesResult();
std::vector<Directory> getDirectories()const;
long getTotalCount()const;
long getPageSize()const;
long getPageNum()const;
long getPageCount()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Directory> directories_;
long totalCount_;
long pageSize_;
long pageNum_;
long pageCount_;
};
}
}
}
#endif // !ALIBABACLOUD_VS_MODEL_DESCRIBEDIRECTORIESRESULT_H_

Some files were not shown because too many files have changed in this diff Show More