1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

LIVE SDK Auto Released By renrang.yl,Version：1.17.4

Browse Source 
Signed-off-by: haowei.yao <haowei.yao@alibaba-inc.com>
This commit is contained in:
haowei.yao
2018-06-13 15:38:41 +08:00
parent 9e756213fa
commit a6256086a8
435 changed files with 34781 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

902
live/include/alibabacloud/live/LiveClient.h Normal file
View File

@@ -0,0 +1,902 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_LIVECLIENT_H_
#define ALIBABACLOUD_LIVE_LIVECLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "LiveExport.h"
#include "model/DescribeLiveRecordNotifyConfigRequest.h"
#include "model/DescribeLiveRecordNotifyConfigResult.h"
#include "model/DescribeLiveDetectNotifyConfigRequest.h"
#include "model/DescribeLiveDetectNotifyConfigResult.h"
#include "model/ModifyCasterComponentRequest.h"
#include "model/ModifyCasterComponentResult.h"
#include "model/UpdateLiveSnapshotDetectPornConfigRequest.h"
#include "model/UpdateLiveSnapshotDetectPornConfigResult.h"
#include "model/EffectCasterUrgentRequest.h"
#include "model/EffectCasterUrgentResult.h"
#include "model/DescribeCasterComponentsRequest.h"
#include "model/DescribeCasterComponentsResult.h"
#include "model/DescribeLiveMixConfigRequest.h"
#include "model/DescribeLiveMixConfigResult.h"
#include "model/CreateLiveStreamRecordIndexFilesRequest.h"
#include "model/CreateLiveStreamRecordIndexFilesResult.h"
#include "model/UpdateCasterSceneConfigRequest.h"
#include "model/UpdateCasterSceneConfigResult.h"
#include "model/DescribeLiveStreamTranscodeInfoRequest.h"
#include "model/DescribeLiveStreamTranscodeInfoResult.h"
#include "model/DescribeLiveStreamsOnlineListRequest.h"
#include "model/DescribeLiveStreamsOnlineListResult.h"
#include "model/DeleteLiveSnapshotDetectPornConfigRequest.h"
#include "model/DeleteLiveSnapshotDetectPornConfigResult.h"
#include "model/CopyCasterSceneConfigRequest.h"
#include "model/CopyCasterSceneConfigResult.h"
#include "model/DescribeLiveDomainTranscodeDataRequest.h"
#include "model/DescribeLiveDomainTranscodeDataResult.h"
#include "model/StopMixStreamsServiceRequest.h"
#include "model/StopMixStreamsServiceResult.h"
#include "model/DeleteLiveStreamTranscodeRequest.h"
#include "model/DeleteLiveStreamTranscodeResult.h"
#include "model/DeleteCasterEpisodeRequest.h"
#include "model/DeleteCasterEpisodeResult.h"
#include "model/DescribeCasterRtcInfoRequest.h"
#include "model/DescribeCasterRtcInfoResult.h"
#include "model/SetCasterSceneConfigRequest.h"
#include "model/SetCasterSceneConfigResult.h"
#include "model/AddTrancodeSEIRequest.h"
#include "model/AddTrancodeSEIResult.h"
#include "model/DescribeLiveStreamBitRateDataRequest.h"
#include "model/DescribeLiveStreamBitRateDataResult.h"
#include "model/DeleteCasterLayoutRequest.h"
#include "model/DeleteCasterLayoutResult.h"
#include "model/DeleteCasterProgramRequest.h"
#include "model/DeleteCasterProgramResult.h"
#include "model/StartCasterSceneRequest.h"
#include "model/StartCasterSceneResult.h"
#include "model/DescribeLiveStreamRecordIndexFileRequest.h"
#include "model/DescribeLiveStreamRecordIndexFileResult.h"
#include "model/AddCasterEpisodeGroupRequest.h"
#include "model/AddCasterEpisodeGroupResult.h"
#include "model/AddLiveMixConfigRequest.h"
#include "model/AddLiveMixConfigResult.h"
#include "model/DescribeCasterConfigRequest.h"
#include "model/DescribeCasterConfigResult.h"
#include "model/CopyCasterRequest.h"
#include "model/CopyCasterResult.h"
#include "model/AddCustomLiveStreamTranscodeRequest.h"
#include "model/AddCustomLiveStreamTranscodeResult.h"
#include "model/AddCasterEpisodeRequest.h"
#include "model/AddCasterEpisodeResult.h"
#include "model/DescribeLiveRecordConfigRequest.h"
#include "model/DescribeLiveRecordConfigResult.h"
#include "model/DeleteLiveRecordNotifyConfigRequest.h"
#include "model/DeleteLiveRecordNotifyConfigResult.h"
#include "model/AddLiveRecordNotifyConfigRequest.h"
#include "model/AddLiveRecordNotifyConfigResult.h"
#include "model/DeleteLiveStreamsNotifyUrlConfigRequest.h"
#include "model/DeleteLiveStreamsNotifyUrlConfigResult.h"
#include "model/DescribeLiveStreamOnlineUserNumRequest.h"
#include "model/DescribeLiveStreamOnlineUserNumResult.h"
#include "model/AddCasterComponentRequest.h"
#include "model/AddCasterComponentResult.h"
#include "model/UpdateLiveMixNotifyConfigRequest.h"
#include "model/UpdateLiveMixNotifyConfigResult.h"
#include "model/DescribeLiveDomainRecordDataRequest.h"
#include "model/DescribeLiveDomainRecordDataResult.h"
#include "model/DeleteCasterVideoResourceRequest.h"
#include "model/DeleteCasterVideoResourceResult.h"
#include "model/DeleteLiveAppSnapshotConfigRequest.h"
#include "model/DeleteLiveAppSnapshotConfigResult.h"
#include "model/DescribeLiveStreamsNotifyUrlConfigRequest.h"
#include "model/DescribeLiveStreamsNotifyUrlConfigResult.h"
#include "model/DeleteLivePullStreamInfoConfigRequest.h"
#include "model/DeleteLivePullStreamInfoConfigResult.h"
#include "model/ModifyCasterProgramRequest.h"
#include "model/ModifyCasterProgramResult.h"
#include "model/StartMixStreamsServiceRequest.h"
#include "model/StartMixStreamsServiceResult.h"
#include "model/DescribeLivePullStreamConfigRequest.h"
#include "model/DescribeLivePullStreamConfigResult.h"
#include "model/SetLiveStreamsNotifyUrlConfigRequest.h"
#include "model/SetLiveStreamsNotifyUrlConfigResult.h"
#include "model/AddLivePullStreamInfoConfigRequest.h"
#include "model/AddLivePullStreamInfoConfigResult.h"
#include "model/DescribeLiveStreamsBlockListRequest.h"
#include "model/DescribeLiveStreamsBlockListResult.h"
#include "model/AddLiveStreamTranscodeRequest.h"
#include "model/AddLiveStreamTranscodeResult.h"
#include "model/AddCasterVideoResourceRequest.h"
#include "model/AddCasterVideoResourceResult.h"
#include "model/AddCasterEpisodeGroupContentRequest.h"
#include "model/AddCasterEpisodeGroupContentResult.h"
#include "model/UpdateLiveDetectNotifyConfigRequest.h"
#include "model/UpdateLiveDetectNotifyConfigResult.h"
#include "model/ModifyCasterVideoResourceRequest.h"
#include "model/ModifyCasterVideoResourceResult.h"
#include "model/ImagePornDetectionRequest.h"
#include "model/ImagePornDetectionResult.h"
#include "model/DescribeCasterStreamUrlRequest.h"
#include "model/DescribeCasterStreamUrlResult.h"
#include "model/DescribeLiveStreamsControlHistoryRequest.h"
#include "model/DescribeLiveStreamsControlHistoryResult.h"
#include "model/StopCasterSceneRequest.h"
#include "model/StopCasterSceneResult.h"
#include "model/DescribeLiveDomainSnapshotDataRequest.h"
#include "model/DescribeLiveDomainSnapshotDataResult.h"
#include "model/DeleteLiveRecordVodConfigRequest.h"
#include "model/DeleteLiveRecordVodConfigResult.h"
#include "model/ModifyCasterEpisodeRequest.h"
#include "model/ModifyCasterEpisodeResult.h"
#include "model/DescribeLiveStreamSnapshotInfoRequest.h"
#include "model/DescribeLiveStreamSnapshotInfoResult.h"
#include "model/StartMultipleStreamMixServiceRequest.h"
#include "model/StartMultipleStreamMixServiceResult.h"
#include "model/StopMultipleStreamMixServiceRequest.h"
#include "model/StopMultipleStreamMixServiceResult.h"
#include "model/DescribeLiveMixNotifyConfigRequest.h"
#include "model/DescribeLiveMixNotifyConfigResult.h"
#include "model/DescribeLiveStreamsFrameRateAndBitRateDataRequest.h"
#include "model/DescribeLiveStreamsFrameRateAndBitRateDataResult.h"
#include "model/CreateCasterRequest.h"
#include "model/CreateCasterResult.h"
#include "model/DescribeLiveStreamRecordContentRequest.h"
#include "model/DescribeLiveStreamRecordContentResult.h"
#include "model/AddMultipleStreamMixServiceRequest.h"
#include "model/AddMultipleStreamMixServiceResult.h"
#include "model/AddLiveSnapshotDetectPornConfigRequest.h"
#include "model/AddLiveSnapshotDetectPornConfigResult.h"
#include "model/DescribeCasterLayoutsRequest.h"
#include "model/DescribeCasterLayoutsResult.h"
#include "model/UpdateLiveRecordNotifyConfigRequest.h"
#include "model/UpdateLiveRecordNotifyConfigResult.h"
#include "model/DescribeLiveSnapshotConfigRequest.h"
#include "model/DescribeLiveSnapshotConfigResult.h"
#include "model/DescribeCasterProgramRequest.h"
#include "model/DescribeCasterProgramResult.h"
#include "model/DescribeLiveStreamHistoryUserNumRequest.h"
#include "model/DescribeLiveStreamHistoryUserNumResult.h"
#include "model/AddLiveAppRecordConfigRequest.h"
#include "model/AddLiveAppRecordConfigResult.h"
#include "model/AddLiveRecordVodConfigRequest.h"
#include "model/AddLiveRecordVodConfigResult.h"
#include "model/DescribeLiveStreamRecordIndexFilesRequest.h"
#include "model/DescribeLiveStreamRecordIndexFilesResult.h"
#include "model/AddCasterProgramRequest.h"
#include "model/AddCasterProgramResult.h"
#include "model/DeleteLiveMixConfigRequest.h"
#include "model/DeleteLiveMixConfigResult.h"
#include "model/ForbidLiveStreamRequest.h"
#include "model/ForbidLiveStreamResult.h"
#include "model/DeleteCasterEpisodeGroupRequest.h"
#include "model/DeleteCasterEpisodeGroupResult.h"
#include "model/DescribeCasterVideoResourcesRequest.h"
#include "model/DescribeCasterVideoResourcesResult.h"
#include "model/UpdateLiveAppSnapshotConfigRequest.h"
#include "model/UpdateLiveAppSnapshotConfigResult.h"
#include "model/DeleteLiveDetectNotifyConfigRequest.h"
#include "model/DeleteLiveDetectNotifyConfigResult.h"
#include "model/EffectCasterVideoResourceRequest.h"
#include "model/EffectCasterVideoResourceResult.h"
#include "model/DeleteLiveMixNotifyConfigRequest.h"
#include "model/DeleteLiveMixNotifyConfigResult.h"
#include "model/AddLiveAppSnapshotConfigRequest.h"
#include "model/AddLiveAppSnapshotConfigResult.h"
#include "model/RemoveMultipleStreamMixServiceRequest.h"
#include "model/RemoveMultipleStreamMixServiceResult.h"
#include "model/DeleteCasterComponentRequest.h"
#include "model/DeleteCasterComponentResult.h"
#include "model/SetCasterConfigRequest.h"
#include "model/SetCasterConfigResult.h"
#include "model/RealTimeRecordCommandRequest.h"
#include "model/RealTimeRecordCommandResult.h"
#include "model/StartCasterRequest.h"
#include "model/StartCasterResult.h"
#include "model/ResumeLiveStreamRequest.h"
#include "model/ResumeLiveStreamResult.h"
#include "model/AddCasterLayoutRequest.h"
#include "model/AddCasterLayoutResult.h"
#include "model/ModifyCasterLayoutRequest.h"
#include "model/ModifyCasterLayoutResult.h"
#include "model/StopCasterRequest.h"
#include "model/StopCasterResult.h"
#include "model/DescribeLiveStreamsPublishListRequest.h"
#include "model/DescribeLiveStreamsPublishListResult.h"
#include "model/DescribeLiveSnapshotDetectPornConfigRequest.h"
#include "model/DescribeLiveSnapshotDetectPornConfigResult.h"
#include "model/DeleteCasterSceneConfigRequest.h"
#include "model/DeleteCasterSceneConfigResult.h"
#include "model/DeleteLiveAppRecordConfigRequest.h"
#include "model/DeleteLiveAppRecordConfigResult.h"
#include "model/DeleteCasterRequest.h"
#include "model/DeleteCasterResult.h"
#include "model/DescribeLiveRecordVodConfigsRequest.h"
#include "model/DescribeLiveRecordVodConfigsResult.h"
#include "model/DescribeCastersRequest.h"
#include "model/DescribeCastersResult.h"
#include "model/AddLiveMixNotifyConfigRequest.h"
#include "model/AddLiveMixNotifyConfigResult.h"
#include "model/AddLiveDetectNotifyConfigRequest.h"
#include "model/AddLiveDetectNotifyConfigResult.h"
#include "model/DescribeCasterScenesRequest.h"
#include "model/DescribeCasterScenesResult.h"
namespace AlibabaCloud
{
namespace Live
{
class ALIBABACLOUD_LIVE_EXPORT LiveClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::DescribeLiveRecordNotifyConfigResult> DescribeLiveRecordNotifyConfigOutcome;
typedef std::future<DescribeLiveRecordNotifyConfigOutcome> DescribeLiveRecordNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveRecordNotifyConfigRequest&, const DescribeLiveRecordNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRecordNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveDetectNotifyConfigResult> DescribeLiveDetectNotifyConfigOutcome;
typedef std::future<DescribeLiveDetectNotifyConfigOutcome> DescribeLiveDetectNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveDetectNotifyConfigRequest&, const DescribeLiveDetectNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDetectNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::ModifyCasterComponentResult> ModifyCasterComponentOutcome;
typedef std::future<ModifyCasterComponentOutcome> ModifyCasterComponentOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ModifyCasterComponentRequest&, const ModifyCasterComponentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCasterComponentAsyncHandler;
typedef Outcome<Error, Model::UpdateLiveSnapshotDetectPornConfigResult> UpdateLiveSnapshotDetectPornConfigOutcome;
typedef std::future<UpdateLiveSnapshotDetectPornConfigOutcome> UpdateLiveSnapshotDetectPornConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveSnapshotDetectPornConfigRequest&, const UpdateLiveSnapshotDetectPornConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveSnapshotDetectPornConfigAsyncHandler;
typedef Outcome<Error, Model::EffectCasterUrgentResult> EffectCasterUrgentOutcome;
typedef std::future<EffectCasterUrgentOutcome> EffectCasterUrgentOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::EffectCasterUrgentRequest&, const EffectCasterUrgentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EffectCasterUrgentAsyncHandler;
typedef Outcome<Error, Model::DescribeCasterComponentsResult> DescribeCasterComponentsOutcome;
typedef std::future<DescribeCasterComponentsOutcome> DescribeCasterComponentsOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeCasterComponentsRequest&, const DescribeCasterComponentsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCasterComponentsAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveMixConfigResult> DescribeLiveMixConfigOutcome;
typedef std::future<DescribeLiveMixConfigOutcome> DescribeLiveMixConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveMixConfigRequest&, const DescribeLiveMixConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveMixConfigAsyncHandler;
typedef Outcome<Error, Model::CreateLiveStreamRecordIndexFilesResult> CreateLiveStreamRecordIndexFilesOutcome;
typedef std::future<CreateLiveStreamRecordIndexFilesOutcome> CreateLiveStreamRecordIndexFilesOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CreateLiveStreamRecordIndexFilesRequest&, const CreateLiveStreamRecordIndexFilesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLiveStreamRecordIndexFilesAsyncHandler;
typedef Outcome<Error, Model::UpdateCasterSceneConfigResult> UpdateCasterSceneConfigOutcome;
typedef std::future<UpdateCasterSceneConfigOutcome> UpdateCasterSceneConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateCasterSceneConfigRequest&, const UpdateCasterSceneConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateCasterSceneConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamTranscodeInfoResult> DescribeLiveStreamTranscodeInfoOutcome;
typedef std::future<DescribeLiveStreamTranscodeInfoOutcome> DescribeLiveStreamTranscodeInfoOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamTranscodeInfoRequest&, const DescribeLiveStreamTranscodeInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamTranscodeInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamsOnlineListResult> DescribeLiveStreamsOnlineListOutcome;
typedef std::future<DescribeLiveStreamsOnlineListOutcome> DescribeLiveStreamsOnlineListOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamsOnlineListRequest&, const DescribeLiveStreamsOnlineListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamsOnlineListAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveSnapshotDetectPornConfigResult> DeleteLiveSnapshotDetectPornConfigOutcome;
typedef std::future<DeleteLiveSnapshotDetectPornConfigOutcome> DeleteLiveSnapshotDetectPornConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveSnapshotDetectPornConfigRequest&, const DeleteLiveSnapshotDetectPornConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveSnapshotDetectPornConfigAsyncHandler;
typedef Outcome<Error, Model::CopyCasterSceneConfigResult> CopyCasterSceneConfigOutcome;
typedef std::future<CopyCasterSceneConfigOutcome> CopyCasterSceneConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CopyCasterSceneConfigRequest&, const CopyCasterSceneConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CopyCasterSceneConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveDomainTranscodeDataResult> DescribeLiveDomainTranscodeDataOutcome;
typedef std::future<DescribeLiveDomainTranscodeDataOutcome> DescribeLiveDomainTranscodeDataOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainTranscodeDataRequest&, const DescribeLiveDomainTranscodeDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainTranscodeDataAsyncHandler;
typedef Outcome<Error, Model::StopMixStreamsServiceResult> StopMixStreamsServiceOutcome;
typedef std::future<StopMixStreamsServiceOutcome> StopMixStreamsServiceOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::StopMixStreamsServiceRequest&, const StopMixStreamsServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopMixStreamsServiceAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveStreamTranscodeResult> DeleteLiveStreamTranscodeOutcome;
typedef std::future<DeleteLiveStreamTranscodeOutcome> DeleteLiveStreamTranscodeOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveStreamTranscodeRequest&, const DeleteLiveStreamTranscodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveStreamTranscodeAsyncHandler;
typedef Outcome<Error, Model::DeleteCasterEpisodeResult> DeleteCasterEpisodeOutcome;
typedef std::future<DeleteCasterEpisodeOutcome> DeleteCasterEpisodeOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteCasterEpisodeRequest&, const DeleteCasterEpisodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCasterEpisodeAsyncHandler;
typedef Outcome<Error, Model::DescribeCasterRtcInfoResult> DescribeCasterRtcInfoOutcome;
typedef std::future<DescribeCasterRtcInfoOutcome> DescribeCasterRtcInfoOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeCasterRtcInfoRequest&, const DescribeCasterRtcInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCasterRtcInfoAsyncHandler;
typedef Outcome<Error, Model::SetCasterSceneConfigResult> SetCasterSceneConfigOutcome;
typedef std::future<SetCasterSceneConfigOutcome> SetCasterSceneConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::SetCasterSceneConfigRequest&, const SetCasterSceneConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetCasterSceneConfigAsyncHandler;
typedef Outcome<Error, Model::AddTrancodeSEIResult> AddTrancodeSEIOutcome;
typedef std::future<AddTrancodeSEIOutcome> AddTrancodeSEIOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddTrancodeSEIRequest&, const AddTrancodeSEIOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddTrancodeSEIAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamBitRateDataResult> DescribeLiveStreamBitRateDataOutcome;
typedef std::future<DescribeLiveStreamBitRateDataOutcome> DescribeLiveStreamBitRateDataOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamBitRateDataRequest&, const DescribeLiveStreamBitRateDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamBitRateDataAsyncHandler;
typedef Outcome<Error, Model::DeleteCasterLayoutResult> DeleteCasterLayoutOutcome;
typedef std::future<DeleteCasterLayoutOutcome> DeleteCasterLayoutOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteCasterLayoutRequest&, const DeleteCasterLayoutOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCasterLayoutAsyncHandler;
typedef Outcome<Error, Model::DeleteCasterProgramResult> DeleteCasterProgramOutcome;
typedef std::future<DeleteCasterProgramOutcome> DeleteCasterProgramOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteCasterProgramRequest&, const DeleteCasterProgramOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCasterProgramAsyncHandler;
typedef Outcome<Error, Model::StartCasterSceneResult> StartCasterSceneOutcome;
typedef std::future<StartCasterSceneOutcome> StartCasterSceneOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::StartCasterSceneRequest&, const StartCasterSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartCasterSceneAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamRecordIndexFileResult> DescribeLiveStreamRecordIndexFileOutcome;
typedef std::future<DescribeLiveStreamRecordIndexFileOutcome> DescribeLiveStreamRecordIndexFileOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamRecordIndexFileRequest&, const DescribeLiveStreamRecordIndexFileOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamRecordIndexFileAsyncHandler;
typedef Outcome<Error, Model::AddCasterEpisodeGroupResult> AddCasterEpisodeGroupOutcome;
typedef std::future<AddCasterEpisodeGroupOutcome> AddCasterEpisodeGroupOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddCasterEpisodeGroupRequest&, const AddCasterEpisodeGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddCasterEpisodeGroupAsyncHandler;
typedef Outcome<Error, Model::AddLiveMixConfigResult> AddLiveMixConfigOutcome;
typedef std::future<AddLiveMixConfigOutcome> AddLiveMixConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveMixConfigRequest&, const AddLiveMixConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveMixConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeCasterConfigResult> DescribeCasterConfigOutcome;
typedef std::future<DescribeCasterConfigOutcome> DescribeCasterConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeCasterConfigRequest&, const DescribeCasterConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCasterConfigAsyncHandler;
typedef Outcome<Error, Model::CopyCasterResult> CopyCasterOutcome;
typedef std::future<CopyCasterOutcome> CopyCasterOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CopyCasterRequest&, const CopyCasterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CopyCasterAsyncHandler;
typedef Outcome<Error, Model::AddCustomLiveStreamTranscodeResult> AddCustomLiveStreamTranscodeOutcome;
typedef std::future<AddCustomLiveStreamTranscodeOutcome> AddCustomLiveStreamTranscodeOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddCustomLiveStreamTranscodeRequest&, const AddCustomLiveStreamTranscodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddCustomLiveStreamTranscodeAsyncHandler;
typedef Outcome<Error, Model::AddCasterEpisodeResult> AddCasterEpisodeOutcome;
typedef std::future<AddCasterEpisodeOutcome> AddCasterEpisodeOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddCasterEpisodeRequest&, const AddCasterEpisodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddCasterEpisodeAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveRecordConfigResult> DescribeLiveRecordConfigOutcome;
typedef std::future<DescribeLiveRecordConfigOutcome> DescribeLiveRecordConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveRecordConfigRequest&, const DescribeLiveRecordConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRecordConfigAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveRecordNotifyConfigResult> DeleteLiveRecordNotifyConfigOutcome;
typedef std::future<DeleteLiveRecordNotifyConfigOutcome> DeleteLiveRecordNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveRecordNotifyConfigRequest&, const DeleteLiveRecordNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveRecordNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::AddLiveRecordNotifyConfigResult> AddLiveRecordNotifyConfigOutcome;
typedef std::future<AddLiveRecordNotifyConfigOutcome> AddLiveRecordNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveRecordNotifyConfigRequest&, const AddLiveRecordNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveRecordNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveStreamsNotifyUrlConfigResult> DeleteLiveStreamsNotifyUrlConfigOutcome;
typedef std::future<DeleteLiveStreamsNotifyUrlConfigOutcome> DeleteLiveStreamsNotifyUrlConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveStreamsNotifyUrlConfigRequest&, const DeleteLiveStreamsNotifyUrlConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveStreamsNotifyUrlConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamOnlineUserNumResult> DescribeLiveStreamOnlineUserNumOutcome;
typedef std::future<DescribeLiveStreamOnlineUserNumOutcome> DescribeLiveStreamOnlineUserNumOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamOnlineUserNumRequest&, const DescribeLiveStreamOnlineUserNumOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamOnlineUserNumAsyncHandler;
typedef Outcome<Error, Model::AddCasterComponentResult> AddCasterComponentOutcome;
typedef std::future<AddCasterComponentOutcome> AddCasterComponentOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddCasterComponentRequest&, const AddCasterComponentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddCasterComponentAsyncHandler;
typedef Outcome<Error, Model::UpdateLiveMixNotifyConfigResult> UpdateLiveMixNotifyConfigOutcome;
typedef std::future<UpdateLiveMixNotifyConfigOutcome> UpdateLiveMixNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveMixNotifyConfigRequest&, const UpdateLiveMixNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveMixNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveDomainRecordDataResult> DescribeLiveDomainRecordDataOutcome;
typedef std::future<DescribeLiveDomainRecordDataOutcome> DescribeLiveDomainRecordDataOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainRecordDataRequest&, const DescribeLiveDomainRecordDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainRecordDataAsyncHandler;
typedef Outcome<Error, Model::DeleteCasterVideoResourceResult> DeleteCasterVideoResourceOutcome;
typedef std::future<DeleteCasterVideoResourceOutcome> DeleteCasterVideoResourceOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteCasterVideoResourceRequest&, const DeleteCasterVideoResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCasterVideoResourceAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveAppSnapshotConfigResult> DeleteLiveAppSnapshotConfigOutcome;
typedef std::future<DeleteLiveAppSnapshotConfigOutcome> DeleteLiveAppSnapshotConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveAppSnapshotConfigRequest&, const DeleteLiveAppSnapshotConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveAppSnapshotConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamsNotifyUrlConfigResult> DescribeLiveStreamsNotifyUrlConfigOutcome;
typedef std::future<DescribeLiveStreamsNotifyUrlConfigOutcome> DescribeLiveStreamsNotifyUrlConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamsNotifyUrlConfigRequest&, const DescribeLiveStreamsNotifyUrlConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamsNotifyUrlConfigAsyncHandler;
typedef Outcome<Error, Model::DeleteLivePullStreamInfoConfigResult> DeleteLivePullStreamInfoConfigOutcome;
typedef std::future<DeleteLivePullStreamInfoConfigOutcome> DeleteLivePullStreamInfoConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLivePullStreamInfoConfigRequest&, const DeleteLivePullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLivePullStreamInfoConfigAsyncHandler;
typedef Outcome<Error, Model::ModifyCasterProgramResult> ModifyCasterProgramOutcome;
typedef std::future<ModifyCasterProgramOutcome> ModifyCasterProgramOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ModifyCasterProgramRequest&, const ModifyCasterProgramOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCasterProgramAsyncHandler;
typedef Outcome<Error, Model::StartMixStreamsServiceResult> StartMixStreamsServiceOutcome;
typedef std::future<StartMixStreamsServiceOutcome> StartMixStreamsServiceOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::StartMixStreamsServiceRequest&, const StartMixStreamsServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartMixStreamsServiceAsyncHandler;
typedef Outcome<Error, Model::DescribeLivePullStreamConfigResult> DescribeLivePullStreamConfigOutcome;
typedef std::future<DescribeLivePullStreamConfigOutcome> DescribeLivePullStreamConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLivePullStreamConfigRequest&, const DescribeLivePullStreamConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLivePullStreamConfigAsyncHandler;
typedef Outcome<Error, Model::SetLiveStreamsNotifyUrlConfigResult> SetLiveStreamsNotifyUrlConfigOutcome;
typedef std::future<SetLiveStreamsNotifyUrlConfigOutcome> SetLiveStreamsNotifyUrlConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::SetLiveStreamsNotifyUrlConfigRequest&, const SetLiveStreamsNotifyUrlConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLiveStreamsNotifyUrlConfigAsyncHandler;
typedef Outcome<Error, Model::AddLivePullStreamInfoConfigResult> AddLivePullStreamInfoConfigOutcome;
typedef std::future<AddLivePullStreamInfoConfigOutcome> AddLivePullStreamInfoConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLivePullStreamInfoConfigRequest&, const AddLivePullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLivePullStreamInfoConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamsBlockListResult> DescribeLiveStreamsBlockListOutcome;
typedef std::future<DescribeLiveStreamsBlockListOutcome> DescribeLiveStreamsBlockListOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamsBlockListRequest&, const DescribeLiveStreamsBlockListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamsBlockListAsyncHandler;
typedef Outcome<Error, Model::AddLiveStreamTranscodeResult> AddLiveStreamTranscodeOutcome;
typedef std::future<AddLiveStreamTranscodeOutcome> AddLiveStreamTranscodeOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveStreamTranscodeRequest&, const AddLiveStreamTranscodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveStreamTranscodeAsyncHandler;
typedef Outcome<Error, Model::AddCasterVideoResourceResult> AddCasterVideoResourceOutcome;
typedef std::future<AddCasterVideoResourceOutcome> AddCasterVideoResourceOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddCasterVideoResourceRequest&, const AddCasterVideoResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddCasterVideoResourceAsyncHandler;
typedef Outcome<Error, Model::AddCasterEpisodeGroupContentResult> AddCasterEpisodeGroupContentOutcome;
typedef std::future<AddCasterEpisodeGroupContentOutcome> AddCasterEpisodeGroupContentOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddCasterEpisodeGroupContentRequest&, const AddCasterEpisodeGroupContentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddCasterEpisodeGroupContentAsyncHandler;
typedef Outcome<Error, Model::UpdateLiveDetectNotifyConfigResult> UpdateLiveDetectNotifyConfigOutcome;
typedef std::future<UpdateLiveDetectNotifyConfigOutcome> UpdateLiveDetectNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveDetectNotifyConfigRequest&, const UpdateLiveDetectNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveDetectNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::ModifyCasterVideoResourceResult> ModifyCasterVideoResourceOutcome;
typedef std::future<ModifyCasterVideoResourceOutcome> ModifyCasterVideoResourceOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ModifyCasterVideoResourceRequest&, const ModifyCasterVideoResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCasterVideoResourceAsyncHandler;
typedef Outcome<Error, Model::ImagePornDetectionResult> ImagePornDetectionOutcome;
typedef std::future<ImagePornDetectionOutcome> ImagePornDetectionOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ImagePornDetectionRequest&, const ImagePornDetectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ImagePornDetectionAsyncHandler;
typedef Outcome<Error, Model::DescribeCasterStreamUrlResult> DescribeCasterStreamUrlOutcome;
typedef std::future<DescribeCasterStreamUrlOutcome> DescribeCasterStreamUrlOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeCasterStreamUrlRequest&, const DescribeCasterStreamUrlOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCasterStreamUrlAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamsControlHistoryResult> DescribeLiveStreamsControlHistoryOutcome;
typedef std::future<DescribeLiveStreamsControlHistoryOutcome> DescribeLiveStreamsControlHistoryOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamsControlHistoryRequest&, const DescribeLiveStreamsControlHistoryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamsControlHistoryAsyncHandler;
typedef Outcome<Error, Model::StopCasterSceneResult> StopCasterSceneOutcome;
typedef std::future<StopCasterSceneOutcome> StopCasterSceneOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::StopCasterSceneRequest&, const StopCasterSceneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopCasterSceneAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveDomainSnapshotDataResult> DescribeLiveDomainSnapshotDataOutcome;
typedef std::future<DescribeLiveDomainSnapshotDataOutcome> DescribeLiveDomainSnapshotDataOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveDomainSnapshotDataRequest&, const DescribeLiveDomainSnapshotDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDomainSnapshotDataAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveRecordVodConfigResult> DeleteLiveRecordVodConfigOutcome;
typedef std::future<DeleteLiveRecordVodConfigOutcome> DeleteLiveRecordVodConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveRecordVodConfigRequest&, const DeleteLiveRecordVodConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveRecordVodConfigAsyncHandler;
typedef Outcome<Error, Model::ModifyCasterEpisodeResult> ModifyCasterEpisodeOutcome;
typedef std::future<ModifyCasterEpisodeOutcome> ModifyCasterEpisodeOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ModifyCasterEpisodeRequest&, const ModifyCasterEpisodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCasterEpisodeAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamSnapshotInfoResult> DescribeLiveStreamSnapshotInfoOutcome;
typedef std::future<DescribeLiveStreamSnapshotInfoOutcome> DescribeLiveStreamSnapshotInfoOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamSnapshotInfoRequest&, const DescribeLiveStreamSnapshotInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamSnapshotInfoAsyncHandler;
typedef Outcome<Error, Model::StartMultipleStreamMixServiceResult> StartMultipleStreamMixServiceOutcome;
typedef std::future<StartMultipleStreamMixServiceOutcome> StartMultipleStreamMixServiceOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::StartMultipleStreamMixServiceRequest&, const StartMultipleStreamMixServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartMultipleStreamMixServiceAsyncHandler;
typedef Outcome<Error, Model::StopMultipleStreamMixServiceResult> StopMultipleStreamMixServiceOutcome;
typedef std::future<StopMultipleStreamMixServiceOutcome> StopMultipleStreamMixServiceOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::StopMultipleStreamMixServiceRequest&, const StopMultipleStreamMixServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopMultipleStreamMixServiceAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveMixNotifyConfigResult> DescribeLiveMixNotifyConfigOutcome;
typedef std::future<DescribeLiveMixNotifyConfigOutcome> DescribeLiveMixNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveMixNotifyConfigRequest&, const DescribeLiveMixNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveMixNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamsFrameRateAndBitRateDataResult> DescribeLiveStreamsFrameRateAndBitRateDataOutcome;
typedef std::future<DescribeLiveStreamsFrameRateAndBitRateDataOutcome> DescribeLiveStreamsFrameRateAndBitRateDataOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamsFrameRateAndBitRateDataRequest&, const DescribeLiveStreamsFrameRateAndBitRateDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamsFrameRateAndBitRateDataAsyncHandler;
typedef Outcome<Error, Model::CreateCasterResult> CreateCasterOutcome;
typedef std::future<CreateCasterOutcome> CreateCasterOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CreateCasterRequest&, const CreateCasterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCasterAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamRecordContentResult> DescribeLiveStreamRecordContentOutcome;
typedef std::future<DescribeLiveStreamRecordContentOutcome> DescribeLiveStreamRecordContentOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamRecordContentRequest&, const DescribeLiveStreamRecordContentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamRecordContentAsyncHandler;
typedef Outcome<Error, Model::AddMultipleStreamMixServiceResult> AddMultipleStreamMixServiceOutcome;
typedef std::future<AddMultipleStreamMixServiceOutcome> AddMultipleStreamMixServiceOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddMultipleStreamMixServiceRequest&, const AddMultipleStreamMixServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddMultipleStreamMixServiceAsyncHandler;
typedef Outcome<Error, Model::AddLiveSnapshotDetectPornConfigResult> AddLiveSnapshotDetectPornConfigOutcome;
typedef std::future<AddLiveSnapshotDetectPornConfigOutcome> AddLiveSnapshotDetectPornConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveSnapshotDetectPornConfigRequest&, const AddLiveSnapshotDetectPornConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveSnapshotDetectPornConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeCasterLayoutsResult> DescribeCasterLayoutsOutcome;
typedef std::future<DescribeCasterLayoutsOutcome> DescribeCasterLayoutsOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeCasterLayoutsRequest&, const DescribeCasterLayoutsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCasterLayoutsAsyncHandler;
typedef Outcome<Error, Model::UpdateLiveRecordNotifyConfigResult> UpdateLiveRecordNotifyConfigOutcome;
typedef std::future<UpdateLiveRecordNotifyConfigOutcome> UpdateLiveRecordNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveRecordNotifyConfigRequest&, const UpdateLiveRecordNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveRecordNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveSnapshotConfigResult> DescribeLiveSnapshotConfigOutcome;
typedef std::future<DescribeLiveSnapshotConfigOutcome> DescribeLiveSnapshotConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveSnapshotConfigRequest&, const DescribeLiveSnapshotConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveSnapshotConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeCasterProgramResult> DescribeCasterProgramOutcome;
typedef std::future<DescribeCasterProgramOutcome> DescribeCasterProgramOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeCasterProgramRequest&, const DescribeCasterProgramOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCasterProgramAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamHistoryUserNumResult> DescribeLiveStreamHistoryUserNumOutcome;
typedef std::future<DescribeLiveStreamHistoryUserNumOutcome> DescribeLiveStreamHistoryUserNumOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamHistoryUserNumRequest&, const DescribeLiveStreamHistoryUserNumOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamHistoryUserNumAsyncHandler;
typedef Outcome<Error, Model::AddLiveAppRecordConfigResult> AddLiveAppRecordConfigOutcome;
typedef std::future<AddLiveAppRecordConfigOutcome> AddLiveAppRecordConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveAppRecordConfigRequest&, const AddLiveAppRecordConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveAppRecordConfigAsyncHandler;
typedef Outcome<Error, Model::AddLiveRecordVodConfigResult> AddLiveRecordVodConfigOutcome;
typedef std::future<AddLiveRecordVodConfigOutcome> AddLiveRecordVodConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveRecordVodConfigRequest&, const AddLiveRecordVodConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveRecordVodConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamRecordIndexFilesResult> DescribeLiveStreamRecordIndexFilesOutcome;
typedef std::future<DescribeLiveStreamRecordIndexFilesOutcome> DescribeLiveStreamRecordIndexFilesOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamRecordIndexFilesRequest&, const DescribeLiveStreamRecordIndexFilesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamRecordIndexFilesAsyncHandler;
typedef Outcome<Error, Model::AddCasterProgramResult> AddCasterProgramOutcome;
typedef std::future<AddCasterProgramOutcome> AddCasterProgramOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddCasterProgramRequest&, const AddCasterProgramOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddCasterProgramAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveMixConfigResult> DeleteLiveMixConfigOutcome;
typedef std::future<DeleteLiveMixConfigOutcome> DeleteLiveMixConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveMixConfigRequest&, const DeleteLiveMixConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveMixConfigAsyncHandler;
typedef Outcome<Error, Model::ForbidLiveStreamResult> ForbidLiveStreamOutcome;
typedef std::future<ForbidLiveStreamOutcome> ForbidLiveStreamOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ForbidLiveStreamRequest&, const ForbidLiveStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ForbidLiveStreamAsyncHandler;
typedef Outcome<Error, Model::DeleteCasterEpisodeGroupResult> DeleteCasterEpisodeGroupOutcome;
typedef std::future<DeleteCasterEpisodeGroupOutcome> DeleteCasterEpisodeGroupOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteCasterEpisodeGroupRequest&, const DeleteCasterEpisodeGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCasterEpisodeGroupAsyncHandler;
typedef Outcome<Error, Model::DescribeCasterVideoResourcesResult> DescribeCasterVideoResourcesOutcome;
typedef std::future<DescribeCasterVideoResourcesOutcome> DescribeCasterVideoResourcesOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeCasterVideoResourcesRequest&, const DescribeCasterVideoResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCasterVideoResourcesAsyncHandler;
typedef Outcome<Error, Model::UpdateLiveAppSnapshotConfigResult> UpdateLiveAppSnapshotConfigOutcome;
typedef std::future<UpdateLiveAppSnapshotConfigOutcome> UpdateLiveAppSnapshotConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::UpdateLiveAppSnapshotConfigRequest&, const UpdateLiveAppSnapshotConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateLiveAppSnapshotConfigAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveDetectNotifyConfigResult> DeleteLiveDetectNotifyConfigOutcome;
typedef std::future<DeleteLiveDetectNotifyConfigOutcome> DeleteLiveDetectNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveDetectNotifyConfigRequest&, const DeleteLiveDetectNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveDetectNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::EffectCasterVideoResourceResult> EffectCasterVideoResourceOutcome;
typedef std::future<EffectCasterVideoResourceOutcome> EffectCasterVideoResourceOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::EffectCasterVideoResourceRequest&, const EffectCasterVideoResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EffectCasterVideoResourceAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveMixNotifyConfigResult> DeleteLiveMixNotifyConfigOutcome;
typedef std::future<DeleteLiveMixNotifyConfigOutcome> DeleteLiveMixNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveMixNotifyConfigRequest&, const DeleteLiveMixNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveMixNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::AddLiveAppSnapshotConfigResult> AddLiveAppSnapshotConfigOutcome;
typedef std::future<AddLiveAppSnapshotConfigOutcome> AddLiveAppSnapshotConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveAppSnapshotConfigRequest&, const AddLiveAppSnapshotConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveAppSnapshotConfigAsyncHandler;
typedef Outcome<Error, Model::RemoveMultipleStreamMixServiceResult> RemoveMultipleStreamMixServiceOutcome;
typedef std::future<RemoveMultipleStreamMixServiceOutcome> RemoveMultipleStreamMixServiceOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::RemoveMultipleStreamMixServiceRequest&, const RemoveMultipleStreamMixServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveMultipleStreamMixServiceAsyncHandler;
typedef Outcome<Error, Model::DeleteCasterComponentResult> DeleteCasterComponentOutcome;
typedef std::future<DeleteCasterComponentOutcome> DeleteCasterComponentOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteCasterComponentRequest&, const DeleteCasterComponentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCasterComponentAsyncHandler;
typedef Outcome<Error, Model::SetCasterConfigResult> SetCasterConfigOutcome;
typedef std::future<SetCasterConfigOutcome> SetCasterConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::SetCasterConfigRequest&, const SetCasterConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetCasterConfigAsyncHandler;
typedef Outcome<Error, Model::RealTimeRecordCommandResult> RealTimeRecordCommandOutcome;
typedef std::future<RealTimeRecordCommandOutcome> RealTimeRecordCommandOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::RealTimeRecordCommandRequest&, const RealTimeRecordCommandOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RealTimeRecordCommandAsyncHandler;
typedef Outcome<Error, Model::StartCasterResult> StartCasterOutcome;
typedef std::future<StartCasterOutcome> StartCasterOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::StartCasterRequest&, const StartCasterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartCasterAsyncHandler;
typedef Outcome<Error, Model::ResumeLiveStreamResult> ResumeLiveStreamOutcome;
typedef std::future<ResumeLiveStreamOutcome> ResumeLiveStreamOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ResumeLiveStreamRequest&, const ResumeLiveStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResumeLiveStreamAsyncHandler;
typedef Outcome<Error, Model::AddCasterLayoutResult> AddCasterLayoutOutcome;
typedef std::future<AddCasterLayoutOutcome> AddCasterLayoutOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddCasterLayoutRequest&, const AddCasterLayoutOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddCasterLayoutAsyncHandler;
typedef Outcome<Error, Model::ModifyCasterLayoutResult> ModifyCasterLayoutOutcome;
typedef std::future<ModifyCasterLayoutOutcome> ModifyCasterLayoutOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ModifyCasterLayoutRequest&, const ModifyCasterLayoutOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyCasterLayoutAsyncHandler;
typedef Outcome<Error, Model::StopCasterResult> StopCasterOutcome;
typedef std::future<StopCasterOutcome> StopCasterOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::StopCasterRequest&, const StopCasterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopCasterAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveStreamsPublishListResult> DescribeLiveStreamsPublishListOutcome;
typedef std::future<DescribeLiveStreamsPublishListOutcome> DescribeLiveStreamsPublishListOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamsPublishListRequest&, const DescribeLiveStreamsPublishListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamsPublishListAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveSnapshotDetectPornConfigResult> DescribeLiveSnapshotDetectPornConfigOutcome;
typedef std::future<DescribeLiveSnapshotDetectPornConfigOutcome> DescribeLiveSnapshotDetectPornConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveSnapshotDetectPornConfigRequest&, const DescribeLiveSnapshotDetectPornConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveSnapshotDetectPornConfigAsyncHandler;
typedef Outcome<Error, Model::DeleteCasterSceneConfigResult> DeleteCasterSceneConfigOutcome;
typedef std::future<DeleteCasterSceneConfigOutcome> DeleteCasterSceneConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteCasterSceneConfigRequest&, const DeleteCasterSceneConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCasterSceneConfigAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveAppRecordConfigResult> DeleteLiveAppRecordConfigOutcome;
typedef std::future<DeleteLiveAppRecordConfigOutcome> DeleteLiveAppRecordConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveAppRecordConfigRequest&, const DeleteLiveAppRecordConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveAppRecordConfigAsyncHandler;
typedef Outcome<Error, Model::DeleteCasterResult> DeleteCasterOutcome;
typedef std::future<DeleteCasterOutcome> DeleteCasterOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteCasterRequest&, const DeleteCasterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCasterAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveRecordVodConfigsResult> DescribeLiveRecordVodConfigsOutcome;
typedef std::future<DescribeLiveRecordVodConfigsOutcome> DescribeLiveRecordVodConfigsOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveRecordVodConfigsRequest&, const DescribeLiveRecordVodConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveRecordVodConfigsAsyncHandler;
typedef Outcome<Error, Model::DescribeCastersResult> DescribeCastersOutcome;
typedef std::future<DescribeCastersOutcome> DescribeCastersOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeCastersRequest&, const DescribeCastersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCastersAsyncHandler;
typedef Outcome<Error, Model::AddLiveMixNotifyConfigResult> AddLiveMixNotifyConfigOutcome;
typedef std::future<AddLiveMixNotifyConfigOutcome> AddLiveMixNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveMixNotifyConfigRequest&, const AddLiveMixNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveMixNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::AddLiveDetectNotifyConfigResult> AddLiveDetectNotifyConfigOutcome;
typedef std::future<AddLiveDetectNotifyConfigOutcome> AddLiveDetectNotifyConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::AddLiveDetectNotifyConfigRequest&, const AddLiveDetectNotifyConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddLiveDetectNotifyConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeCasterScenesResult> DescribeCasterScenesOutcome;
typedef std::future<DescribeCasterScenesOutcome> DescribeCasterScenesOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeCasterScenesRequest&, const DescribeCasterScenesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCasterScenesAsyncHandler;
LiveClient(const Credentials &credentials, const ClientConfiguration &configuration);
LiveClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
LiveClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~LiveClient();
DescribeLiveRecordNotifyConfigOutcome describeLiveRecordNotifyConfig(const Model::DescribeLiveRecordNotifyConfigRequest &request)const;
void describeLiveRecordNotifyConfigAsync(const Model::DescribeLiveRecordNotifyConfigRequest& request, const DescribeLiveRecordNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveRecordNotifyConfigOutcomeCallable describeLiveRecordNotifyConfigCallable(const Model::DescribeLiveRecordNotifyConfigRequest& request) const;
DescribeLiveDetectNotifyConfigOutcome describeLiveDetectNotifyConfig(const Model::DescribeLiveDetectNotifyConfigRequest &request)const;
void describeLiveDetectNotifyConfigAsync(const Model::DescribeLiveDetectNotifyConfigRequest& request, const DescribeLiveDetectNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveDetectNotifyConfigOutcomeCallable describeLiveDetectNotifyConfigCallable(const Model::DescribeLiveDetectNotifyConfigRequest& request) const;
ModifyCasterComponentOutcome modifyCasterComponent(const Model::ModifyCasterComponentRequest &request)const;
void modifyCasterComponentAsync(const Model::ModifyCasterComponentRequest& request, const ModifyCasterComponentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyCasterComponentOutcomeCallable modifyCasterComponentCallable(const Model::ModifyCasterComponentRequest& request) const;
UpdateLiveSnapshotDetectPornConfigOutcome updateLiveSnapshotDetectPornConfig(const Model::UpdateLiveSnapshotDetectPornConfigRequest &request)const;
void updateLiveSnapshotDetectPornConfigAsync(const Model::UpdateLiveSnapshotDetectPornConfigRequest& request, const UpdateLiveSnapshotDetectPornConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveSnapshotDetectPornConfigOutcomeCallable updateLiveSnapshotDetectPornConfigCallable(const Model::UpdateLiveSnapshotDetectPornConfigRequest& request) const;
EffectCasterUrgentOutcome effectCasterUrgent(const Model::EffectCasterUrgentRequest &request)const;
void effectCasterUrgentAsync(const Model::EffectCasterUrgentRequest& request, const EffectCasterUrgentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EffectCasterUrgentOutcomeCallable effectCasterUrgentCallable(const Model::EffectCasterUrgentRequest& request) const;
DescribeCasterComponentsOutcome describeCasterComponents(const Model::DescribeCasterComponentsRequest &request)const;
void describeCasterComponentsAsync(const Model::DescribeCasterComponentsRequest& request, const DescribeCasterComponentsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCasterComponentsOutcomeCallable describeCasterComponentsCallable(const Model::DescribeCasterComponentsRequest& request) const;
DescribeLiveMixConfigOutcome describeLiveMixConfig(const Model::DescribeLiveMixConfigRequest &request)const;
void describeLiveMixConfigAsync(const Model::DescribeLiveMixConfigRequest& request, const DescribeLiveMixConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveMixConfigOutcomeCallable describeLiveMixConfigCallable(const Model::DescribeLiveMixConfigRequest& request) const;
CreateLiveStreamRecordIndexFilesOutcome createLiveStreamRecordIndexFiles(const Model::CreateLiveStreamRecordIndexFilesRequest &request)const;
void createLiveStreamRecordIndexFilesAsync(const Model::CreateLiveStreamRecordIndexFilesRequest& request, const CreateLiveStreamRecordIndexFilesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLiveStreamRecordIndexFilesOutcomeCallable createLiveStreamRecordIndexFilesCallable(const Model::CreateLiveStreamRecordIndexFilesRequest& request) const;
UpdateCasterSceneConfigOutcome updateCasterSceneConfig(const Model::UpdateCasterSceneConfigRequest &request)const;
void updateCasterSceneConfigAsync(const Model::UpdateCasterSceneConfigRequest& request, const UpdateCasterSceneConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateCasterSceneConfigOutcomeCallable updateCasterSceneConfigCallable(const Model::UpdateCasterSceneConfigRequest& request) const;
DescribeLiveStreamTranscodeInfoOutcome describeLiveStreamTranscodeInfo(const Model::DescribeLiveStreamTranscodeInfoRequest &request)const;
void describeLiveStreamTranscodeInfoAsync(const Model::DescribeLiveStreamTranscodeInfoRequest& request, const DescribeLiveStreamTranscodeInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamTranscodeInfoOutcomeCallable describeLiveStreamTranscodeInfoCallable(const Model::DescribeLiveStreamTranscodeInfoRequest& request) const;
DescribeLiveStreamsOnlineListOutcome describeLiveStreamsOnlineList(const Model::DescribeLiveStreamsOnlineListRequest &request)const;
void describeLiveStreamsOnlineListAsync(const Model::DescribeLiveStreamsOnlineListRequest& request, const DescribeLiveStreamsOnlineListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamsOnlineListOutcomeCallable describeLiveStreamsOnlineListCallable(const Model::DescribeLiveStreamsOnlineListRequest& request) const;
DeleteLiveSnapshotDetectPornConfigOutcome deleteLiveSnapshotDetectPornConfig(const Model::DeleteLiveSnapshotDetectPornConfigRequest &request)const;
void deleteLiveSnapshotDetectPornConfigAsync(const Model::DeleteLiveSnapshotDetectPornConfigRequest& request, const DeleteLiveSnapshotDetectPornConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveSnapshotDetectPornConfigOutcomeCallable deleteLiveSnapshotDetectPornConfigCallable(const Model::DeleteLiveSnapshotDetectPornConfigRequest& request) const;
CopyCasterSceneConfigOutcome copyCasterSceneConfig(const Model::CopyCasterSceneConfigRequest &request)const;
void copyCasterSceneConfigAsync(const Model::CopyCasterSceneConfigRequest& request, const CopyCasterSceneConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CopyCasterSceneConfigOutcomeCallable copyCasterSceneConfigCallable(const Model::CopyCasterSceneConfigRequest& request) const;
DescribeLiveDomainTranscodeDataOutcome describeLiveDomainTranscodeData(const Model::DescribeLiveDomainTranscodeDataRequest &request)const;
void describeLiveDomainTranscodeDataAsync(const Model::DescribeLiveDomainTranscodeDataRequest& request, const DescribeLiveDomainTranscodeDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveDomainTranscodeDataOutcomeCallable describeLiveDomainTranscodeDataCallable(const Model::DescribeLiveDomainTranscodeDataRequest& request) const;
StopMixStreamsServiceOutcome stopMixStreamsService(const Model::StopMixStreamsServiceRequest &request)const;
void stopMixStreamsServiceAsync(const Model::StopMixStreamsServiceRequest& request, const StopMixStreamsServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopMixStreamsServiceOutcomeCallable stopMixStreamsServiceCallable(const Model::StopMixStreamsServiceRequest& request) const;
DeleteLiveStreamTranscodeOutcome deleteLiveStreamTranscode(const Model::DeleteLiveStreamTranscodeRequest &request)const;
void deleteLiveStreamTranscodeAsync(const Model::DeleteLiveStreamTranscodeRequest& request, const DeleteLiveStreamTranscodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveStreamTranscodeOutcomeCallable deleteLiveStreamTranscodeCallable(const Model::DeleteLiveStreamTranscodeRequest& request) const;
DeleteCasterEpisodeOutcome deleteCasterEpisode(const Model::DeleteCasterEpisodeRequest &request)const;
void deleteCasterEpisodeAsync(const Model::DeleteCasterEpisodeRequest& request, const DeleteCasterEpisodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCasterEpisodeOutcomeCallable deleteCasterEpisodeCallable(const Model::DeleteCasterEpisodeRequest& request) const;
DescribeCasterRtcInfoOutcome describeCasterRtcInfo(const Model::DescribeCasterRtcInfoRequest &request)const;
void describeCasterRtcInfoAsync(const Model::DescribeCasterRtcInfoRequest& request, const DescribeCasterRtcInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCasterRtcInfoOutcomeCallable describeCasterRtcInfoCallable(const Model::DescribeCasterRtcInfoRequest& request) const;
SetCasterSceneConfigOutcome setCasterSceneConfig(const Model::SetCasterSceneConfigRequest &request)const;
void setCasterSceneConfigAsync(const Model::SetCasterSceneConfigRequest& request, const SetCasterSceneConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetCasterSceneConfigOutcomeCallable setCasterSceneConfigCallable(const Model::SetCasterSceneConfigRequest& request) const;
AddTrancodeSEIOutcome addTrancodeSEI(const Model::AddTrancodeSEIRequest &request)const;
void addTrancodeSEIAsync(const Model::AddTrancodeSEIRequest& request, const AddTrancodeSEIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddTrancodeSEIOutcomeCallable addTrancodeSEICallable(const Model::AddTrancodeSEIRequest& request) const;
DescribeLiveStreamBitRateDataOutcome describeLiveStreamBitRateData(const Model::DescribeLiveStreamBitRateDataRequest &request)const;
void describeLiveStreamBitRateDataAsync(const Model::DescribeLiveStreamBitRateDataRequest& request, const DescribeLiveStreamBitRateDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamBitRateDataOutcomeCallable describeLiveStreamBitRateDataCallable(const Model::DescribeLiveStreamBitRateDataRequest& request) const;
DeleteCasterLayoutOutcome deleteCasterLayout(const Model::DeleteCasterLayoutRequest &request)const;
void deleteCasterLayoutAsync(const Model::DeleteCasterLayoutRequest& request, const DeleteCasterLayoutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCasterLayoutOutcomeCallable deleteCasterLayoutCallable(const Model::DeleteCasterLayoutRequest& request) const;
DeleteCasterProgramOutcome deleteCasterProgram(const Model::DeleteCasterProgramRequest &request)const;
void deleteCasterProgramAsync(const Model::DeleteCasterProgramRequest& request, const DeleteCasterProgramAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCasterProgramOutcomeCallable deleteCasterProgramCallable(const Model::DeleteCasterProgramRequest& request) const;
StartCasterSceneOutcome startCasterScene(const Model::StartCasterSceneRequest &request)const;
void startCasterSceneAsync(const Model::StartCasterSceneRequest& request, const StartCasterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartCasterSceneOutcomeCallable startCasterSceneCallable(const Model::StartCasterSceneRequest& request) const;
DescribeLiveStreamRecordIndexFileOutcome describeLiveStreamRecordIndexFile(const Model::DescribeLiveStreamRecordIndexFileRequest &request)const;
void describeLiveStreamRecordIndexFileAsync(const Model::DescribeLiveStreamRecordIndexFileRequest& request, const DescribeLiveStreamRecordIndexFileAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamRecordIndexFileOutcomeCallable describeLiveStreamRecordIndexFileCallable(const Model::DescribeLiveStreamRecordIndexFileRequest& request) const;
AddCasterEpisodeGroupOutcome addCasterEpisodeGroup(const Model::AddCasterEpisodeGroupRequest &request)const;
void addCasterEpisodeGroupAsync(const Model::AddCasterEpisodeGroupRequest& request, const AddCasterEpisodeGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddCasterEpisodeGroupOutcomeCallable addCasterEpisodeGroupCallable(const Model::AddCasterEpisodeGroupRequest& request) const;
AddLiveMixConfigOutcome addLiveMixConfig(const Model::AddLiveMixConfigRequest &request)const;
void addLiveMixConfigAsync(const Model::AddLiveMixConfigRequest& request, const AddLiveMixConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveMixConfigOutcomeCallable addLiveMixConfigCallable(const Model::AddLiveMixConfigRequest& request) const;
DescribeCasterConfigOutcome describeCasterConfig(const Model::DescribeCasterConfigRequest &request)const;
void describeCasterConfigAsync(const Model::DescribeCasterConfigRequest& request, const DescribeCasterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCasterConfigOutcomeCallable describeCasterConfigCallable(const Model::DescribeCasterConfigRequest& request) const;
CopyCasterOutcome copyCaster(const Model::CopyCasterRequest &request)const;
void copyCasterAsync(const Model::CopyCasterRequest& request, const CopyCasterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CopyCasterOutcomeCallable copyCasterCallable(const Model::CopyCasterRequest& request) const;
AddCustomLiveStreamTranscodeOutcome addCustomLiveStreamTranscode(const Model::AddCustomLiveStreamTranscodeRequest &request)const;
void addCustomLiveStreamTranscodeAsync(const Model::AddCustomLiveStreamTranscodeRequest& request, const AddCustomLiveStreamTranscodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddCustomLiveStreamTranscodeOutcomeCallable addCustomLiveStreamTranscodeCallable(const Model::AddCustomLiveStreamTranscodeRequest& request) const;
AddCasterEpisodeOutcome addCasterEpisode(const Model::AddCasterEpisodeRequest &request)const;
void addCasterEpisodeAsync(const Model::AddCasterEpisodeRequest& request, const AddCasterEpisodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddCasterEpisodeOutcomeCallable addCasterEpisodeCallable(const Model::AddCasterEpisodeRequest& request) const;
DescribeLiveRecordConfigOutcome describeLiveRecordConfig(const Model::DescribeLiveRecordConfigRequest &request)const;
void describeLiveRecordConfigAsync(const Model::DescribeLiveRecordConfigRequest& request, const DescribeLiveRecordConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveRecordConfigOutcomeCallable describeLiveRecordConfigCallable(const Model::DescribeLiveRecordConfigRequest& request) const;
DeleteLiveRecordNotifyConfigOutcome deleteLiveRecordNotifyConfig(const Model::DeleteLiveRecordNotifyConfigRequest &request)const;
void deleteLiveRecordNotifyConfigAsync(const Model::DeleteLiveRecordNotifyConfigRequest& request, const DeleteLiveRecordNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveRecordNotifyConfigOutcomeCallable deleteLiveRecordNotifyConfigCallable(const Model::DeleteLiveRecordNotifyConfigRequest& request) const;
AddLiveRecordNotifyConfigOutcome addLiveRecordNotifyConfig(const Model::AddLiveRecordNotifyConfigRequest &request)const;
void addLiveRecordNotifyConfigAsync(const Model::AddLiveRecordNotifyConfigRequest& request, const AddLiveRecordNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveRecordNotifyConfigOutcomeCallable addLiveRecordNotifyConfigCallable(const Model::AddLiveRecordNotifyConfigRequest& request) const;
DeleteLiveStreamsNotifyUrlConfigOutcome deleteLiveStreamsNotifyUrlConfig(const Model::DeleteLiveStreamsNotifyUrlConfigRequest &request)const;
void deleteLiveStreamsNotifyUrlConfigAsync(const Model::DeleteLiveStreamsNotifyUrlConfigRequest& request, const DeleteLiveStreamsNotifyUrlConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveStreamsNotifyUrlConfigOutcomeCallable deleteLiveStreamsNotifyUrlConfigCallable(const Model::DeleteLiveStreamsNotifyUrlConfigRequest& request) const;
DescribeLiveStreamOnlineUserNumOutcome describeLiveStreamOnlineUserNum(const Model::DescribeLiveStreamOnlineUserNumRequest &request)const;
void describeLiveStreamOnlineUserNumAsync(const Model::DescribeLiveStreamOnlineUserNumRequest& request, const DescribeLiveStreamOnlineUserNumAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamOnlineUserNumOutcomeCallable describeLiveStreamOnlineUserNumCallable(const Model::DescribeLiveStreamOnlineUserNumRequest& request) const;
AddCasterComponentOutcome addCasterComponent(const Model::AddCasterComponentRequest &request)const;
void addCasterComponentAsync(const Model::AddCasterComponentRequest& request, const AddCasterComponentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddCasterComponentOutcomeCallable addCasterComponentCallable(const Model::AddCasterComponentRequest& request) const;
UpdateLiveMixNotifyConfigOutcome updateLiveMixNotifyConfig(const Model::UpdateLiveMixNotifyConfigRequest &request)const;
void updateLiveMixNotifyConfigAsync(const Model::UpdateLiveMixNotifyConfigRequest& request, const UpdateLiveMixNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveMixNotifyConfigOutcomeCallable updateLiveMixNotifyConfigCallable(const Model::UpdateLiveMixNotifyConfigRequest& request) const;
DescribeLiveDomainRecordDataOutcome describeLiveDomainRecordData(const Model::DescribeLiveDomainRecordDataRequest &request)const;
void describeLiveDomainRecordDataAsync(const Model::DescribeLiveDomainRecordDataRequest& request, const DescribeLiveDomainRecordDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveDomainRecordDataOutcomeCallable describeLiveDomainRecordDataCallable(const Model::DescribeLiveDomainRecordDataRequest& request) const;
DeleteCasterVideoResourceOutcome deleteCasterVideoResource(const Model::DeleteCasterVideoResourceRequest &request)const;
void deleteCasterVideoResourceAsync(const Model::DeleteCasterVideoResourceRequest& request, const DeleteCasterVideoResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCasterVideoResourceOutcomeCallable deleteCasterVideoResourceCallable(const Model::DeleteCasterVideoResourceRequest& request) const;
DeleteLiveAppSnapshotConfigOutcome deleteLiveAppSnapshotConfig(const Model::DeleteLiveAppSnapshotConfigRequest &request)const;
void deleteLiveAppSnapshotConfigAsync(const Model::DeleteLiveAppSnapshotConfigRequest& request, const DeleteLiveAppSnapshotConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveAppSnapshotConfigOutcomeCallable deleteLiveAppSnapshotConfigCallable(const Model::DeleteLiveAppSnapshotConfigRequest& request) const;
DescribeLiveStreamsNotifyUrlConfigOutcome describeLiveStreamsNotifyUrlConfig(const Model::DescribeLiveStreamsNotifyUrlConfigRequest &request)const;
void describeLiveStreamsNotifyUrlConfigAsync(const Model::DescribeLiveStreamsNotifyUrlConfigRequest& request, const DescribeLiveStreamsNotifyUrlConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamsNotifyUrlConfigOutcomeCallable describeLiveStreamsNotifyUrlConfigCallable(const Model::DescribeLiveStreamsNotifyUrlConfigRequest& request) const;
DeleteLivePullStreamInfoConfigOutcome deleteLivePullStreamInfoConfig(const Model::DeleteLivePullStreamInfoConfigRequest &request)const;
void deleteLivePullStreamInfoConfigAsync(const Model::DeleteLivePullStreamInfoConfigRequest& request, const DeleteLivePullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLivePullStreamInfoConfigOutcomeCallable deleteLivePullStreamInfoConfigCallable(const Model::DeleteLivePullStreamInfoConfigRequest& request) const;
ModifyCasterProgramOutcome modifyCasterProgram(const Model::ModifyCasterProgramRequest &request)const;
void modifyCasterProgramAsync(const Model::ModifyCasterProgramRequest& request, const ModifyCasterProgramAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyCasterProgramOutcomeCallable modifyCasterProgramCallable(const Model::ModifyCasterProgramRequest& request) const;
StartMixStreamsServiceOutcome startMixStreamsService(const Model::StartMixStreamsServiceRequest &request)const;
void startMixStreamsServiceAsync(const Model::StartMixStreamsServiceRequest& request, const StartMixStreamsServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartMixStreamsServiceOutcomeCallable startMixStreamsServiceCallable(const Model::StartMixStreamsServiceRequest& request) const;
DescribeLivePullStreamConfigOutcome describeLivePullStreamConfig(const Model::DescribeLivePullStreamConfigRequest &request)const;
void describeLivePullStreamConfigAsync(const Model::DescribeLivePullStreamConfigRequest& request, const DescribeLivePullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLivePullStreamConfigOutcomeCallable describeLivePullStreamConfigCallable(const Model::DescribeLivePullStreamConfigRequest& request) const;
SetLiveStreamsNotifyUrlConfigOutcome setLiveStreamsNotifyUrlConfig(const Model::SetLiveStreamsNotifyUrlConfigRequest &request)const;
void setLiveStreamsNotifyUrlConfigAsync(const Model::SetLiveStreamsNotifyUrlConfigRequest& request, const SetLiveStreamsNotifyUrlConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLiveStreamsNotifyUrlConfigOutcomeCallable setLiveStreamsNotifyUrlConfigCallable(const Model::SetLiveStreamsNotifyUrlConfigRequest& request) const;
AddLivePullStreamInfoConfigOutcome addLivePullStreamInfoConfig(const Model::AddLivePullStreamInfoConfigRequest &request)const;
void addLivePullStreamInfoConfigAsync(const Model::AddLivePullStreamInfoConfigRequest& request, const AddLivePullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLivePullStreamInfoConfigOutcomeCallable addLivePullStreamInfoConfigCallable(const Model::AddLivePullStreamInfoConfigRequest& request) const;
DescribeLiveStreamsBlockListOutcome describeLiveStreamsBlockList(const Model::DescribeLiveStreamsBlockListRequest &request)const;
void describeLiveStreamsBlockListAsync(const Model::DescribeLiveStreamsBlockListRequest& request, const DescribeLiveStreamsBlockListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamsBlockListOutcomeCallable describeLiveStreamsBlockListCallable(const Model::DescribeLiveStreamsBlockListRequest& request) const;
AddLiveStreamTranscodeOutcome addLiveStreamTranscode(const Model::AddLiveStreamTranscodeRequest &request)const;
void addLiveStreamTranscodeAsync(const Model::AddLiveStreamTranscodeRequest& request, const AddLiveStreamTranscodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveStreamTranscodeOutcomeCallable addLiveStreamTranscodeCallable(const Model::AddLiveStreamTranscodeRequest& request) const;
AddCasterVideoResourceOutcome addCasterVideoResource(const Model::AddCasterVideoResourceRequest &request)const;
void addCasterVideoResourceAsync(const Model::AddCasterVideoResourceRequest& request, const AddCasterVideoResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddCasterVideoResourceOutcomeCallable addCasterVideoResourceCallable(const Model::AddCasterVideoResourceRequest& request) const;
AddCasterEpisodeGroupContentOutcome addCasterEpisodeGroupContent(const Model::AddCasterEpisodeGroupContentRequest &request)const;
void addCasterEpisodeGroupContentAsync(const Model::AddCasterEpisodeGroupContentRequest& request, const AddCasterEpisodeGroupContentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddCasterEpisodeGroupContentOutcomeCallable addCasterEpisodeGroupContentCallable(const Model::AddCasterEpisodeGroupContentRequest& request) const;
UpdateLiveDetectNotifyConfigOutcome updateLiveDetectNotifyConfig(const Model::UpdateLiveDetectNotifyConfigRequest &request)const;
void updateLiveDetectNotifyConfigAsync(const Model::UpdateLiveDetectNotifyConfigRequest& request, const UpdateLiveDetectNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveDetectNotifyConfigOutcomeCallable updateLiveDetectNotifyConfigCallable(const Model::UpdateLiveDetectNotifyConfigRequest& request) const;
ModifyCasterVideoResourceOutcome modifyCasterVideoResource(const Model::ModifyCasterVideoResourceRequest &request)const;
void modifyCasterVideoResourceAsync(const Model::ModifyCasterVideoResourceRequest& request, const ModifyCasterVideoResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyCasterVideoResourceOutcomeCallable modifyCasterVideoResourceCallable(const Model::ModifyCasterVideoResourceRequest& request) const;
ImagePornDetectionOutcome imagePornDetection(const Model::ImagePornDetectionRequest &request)const;
void imagePornDetectionAsync(const Model::ImagePornDetectionRequest& request, const ImagePornDetectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ImagePornDetectionOutcomeCallable imagePornDetectionCallable(const Model::ImagePornDetectionRequest& request) const;
DescribeCasterStreamUrlOutcome describeCasterStreamUrl(const Model::DescribeCasterStreamUrlRequest &request)const;
void describeCasterStreamUrlAsync(const Model::DescribeCasterStreamUrlRequest& request, const DescribeCasterStreamUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCasterStreamUrlOutcomeCallable describeCasterStreamUrlCallable(const Model::DescribeCasterStreamUrlRequest& request) const;
DescribeLiveStreamsControlHistoryOutcome describeLiveStreamsControlHistory(const Model::DescribeLiveStreamsControlHistoryRequest &request)const;
void describeLiveStreamsControlHistoryAsync(const Model::DescribeLiveStreamsControlHistoryRequest& request, const DescribeLiveStreamsControlHistoryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamsControlHistoryOutcomeCallable describeLiveStreamsControlHistoryCallable(const Model::DescribeLiveStreamsControlHistoryRequest& request) const;
StopCasterSceneOutcome stopCasterScene(const Model::StopCasterSceneRequest &request)const;
void stopCasterSceneAsync(const Model::StopCasterSceneRequest& request, const StopCasterSceneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopCasterSceneOutcomeCallable stopCasterSceneCallable(const Model::StopCasterSceneRequest& request) const;
DescribeLiveDomainSnapshotDataOutcome describeLiveDomainSnapshotData(const Model::DescribeLiveDomainSnapshotDataRequest &request)const;
void describeLiveDomainSnapshotDataAsync(const Model::DescribeLiveDomainSnapshotDataRequest& request, const DescribeLiveDomainSnapshotDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveDomainSnapshotDataOutcomeCallable describeLiveDomainSnapshotDataCallable(const Model::DescribeLiveDomainSnapshotDataRequest& request) const;
DeleteLiveRecordVodConfigOutcome deleteLiveRecordVodConfig(const Model::DeleteLiveRecordVodConfigRequest &request)const;
void deleteLiveRecordVodConfigAsync(const Model::DeleteLiveRecordVodConfigRequest& request, const DeleteLiveRecordVodConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveRecordVodConfigOutcomeCallable deleteLiveRecordVodConfigCallable(const Model::DeleteLiveRecordVodConfigRequest& request) const;
ModifyCasterEpisodeOutcome modifyCasterEpisode(const Model::ModifyCasterEpisodeRequest &request)const;
void modifyCasterEpisodeAsync(const Model::ModifyCasterEpisodeRequest& request, const ModifyCasterEpisodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyCasterEpisodeOutcomeCallable modifyCasterEpisodeCallable(const Model::ModifyCasterEpisodeRequest& request) const;
DescribeLiveStreamSnapshotInfoOutcome describeLiveStreamSnapshotInfo(const Model::DescribeLiveStreamSnapshotInfoRequest &request)const;
void describeLiveStreamSnapshotInfoAsync(const Model::DescribeLiveStreamSnapshotInfoRequest& request, const DescribeLiveStreamSnapshotInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamSnapshotInfoOutcomeCallable describeLiveStreamSnapshotInfoCallable(const Model::DescribeLiveStreamSnapshotInfoRequest& request) const;
StartMultipleStreamMixServiceOutcome startMultipleStreamMixService(const Model::StartMultipleStreamMixServiceRequest &request)const;
void startMultipleStreamMixServiceAsync(const Model::StartMultipleStreamMixServiceRequest& request, const StartMultipleStreamMixServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartMultipleStreamMixServiceOutcomeCallable startMultipleStreamMixServiceCallable(const Model::StartMultipleStreamMixServiceRequest& request) const;
StopMultipleStreamMixServiceOutcome stopMultipleStreamMixService(const Model::StopMultipleStreamMixServiceRequest &request)const;
void stopMultipleStreamMixServiceAsync(const Model::StopMultipleStreamMixServiceRequest& request, const StopMultipleStreamMixServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopMultipleStreamMixServiceOutcomeCallable stopMultipleStreamMixServiceCallable(const Model::StopMultipleStreamMixServiceRequest& request) const;
DescribeLiveMixNotifyConfigOutcome describeLiveMixNotifyConfig(const Model::DescribeLiveMixNotifyConfigRequest &request)const;
void describeLiveMixNotifyConfigAsync(const Model::DescribeLiveMixNotifyConfigRequest& request, const DescribeLiveMixNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveMixNotifyConfigOutcomeCallable describeLiveMixNotifyConfigCallable(const Model::DescribeLiveMixNotifyConfigRequest& request) const;
DescribeLiveStreamsFrameRateAndBitRateDataOutcome describeLiveStreamsFrameRateAndBitRateData(const Model::DescribeLiveStreamsFrameRateAndBitRateDataRequest &request)const;
void describeLiveStreamsFrameRateAndBitRateDataAsync(const Model::DescribeLiveStreamsFrameRateAndBitRateDataRequest& request, const DescribeLiveStreamsFrameRateAndBitRateDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamsFrameRateAndBitRateDataOutcomeCallable describeLiveStreamsFrameRateAndBitRateDataCallable(const Model::DescribeLiveStreamsFrameRateAndBitRateDataRequest& request) const;
CreateCasterOutcome createCaster(const Model::CreateCasterRequest &request)const;
void createCasterAsync(const Model::CreateCasterRequest& request, const CreateCasterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateCasterOutcomeCallable createCasterCallable(const Model::CreateCasterRequest& request) const;
DescribeLiveStreamRecordContentOutcome describeLiveStreamRecordContent(const Model::DescribeLiveStreamRecordContentRequest &request)const;
void describeLiveStreamRecordContentAsync(const Model::DescribeLiveStreamRecordContentRequest& request, const DescribeLiveStreamRecordContentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamRecordContentOutcomeCallable describeLiveStreamRecordContentCallable(const Model::DescribeLiveStreamRecordContentRequest& request) const;
AddMultipleStreamMixServiceOutcome addMultipleStreamMixService(const Model::AddMultipleStreamMixServiceRequest &request)const;
void addMultipleStreamMixServiceAsync(const Model::AddMultipleStreamMixServiceRequest& request, const AddMultipleStreamMixServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddMultipleStreamMixServiceOutcomeCallable addMultipleStreamMixServiceCallable(const Model::AddMultipleStreamMixServiceRequest& request) const;
AddLiveSnapshotDetectPornConfigOutcome addLiveSnapshotDetectPornConfig(const Model::AddLiveSnapshotDetectPornConfigRequest &request)const;
void addLiveSnapshotDetectPornConfigAsync(const Model::AddLiveSnapshotDetectPornConfigRequest& request, const AddLiveSnapshotDetectPornConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveSnapshotDetectPornConfigOutcomeCallable addLiveSnapshotDetectPornConfigCallable(const Model::AddLiveSnapshotDetectPornConfigRequest& request) const;
DescribeCasterLayoutsOutcome describeCasterLayouts(const Model::DescribeCasterLayoutsRequest &request)const;
void describeCasterLayoutsAsync(const Model::DescribeCasterLayoutsRequest& request, const DescribeCasterLayoutsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCasterLayoutsOutcomeCallable describeCasterLayoutsCallable(const Model::DescribeCasterLayoutsRequest& request) const;
UpdateLiveRecordNotifyConfigOutcome updateLiveRecordNotifyConfig(const Model::UpdateLiveRecordNotifyConfigRequest &request)const;
void updateLiveRecordNotifyConfigAsync(const Model::UpdateLiveRecordNotifyConfigRequest& request, const UpdateLiveRecordNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveRecordNotifyConfigOutcomeCallable updateLiveRecordNotifyConfigCallable(const Model::UpdateLiveRecordNotifyConfigRequest& request) const;
DescribeLiveSnapshotConfigOutcome describeLiveSnapshotConfig(const Model::DescribeLiveSnapshotConfigRequest &request)const;
void describeLiveSnapshotConfigAsync(const Model::DescribeLiveSnapshotConfigRequest& request, const DescribeLiveSnapshotConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveSnapshotConfigOutcomeCallable describeLiveSnapshotConfigCallable(const Model::DescribeLiveSnapshotConfigRequest& request) const;
DescribeCasterProgramOutcome describeCasterProgram(const Model::DescribeCasterProgramRequest &request)const;
void describeCasterProgramAsync(const Model::DescribeCasterProgramRequest& request, const DescribeCasterProgramAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCasterProgramOutcomeCallable describeCasterProgramCallable(const Model::DescribeCasterProgramRequest& request) const;
DescribeLiveStreamHistoryUserNumOutcome describeLiveStreamHistoryUserNum(const Model::DescribeLiveStreamHistoryUserNumRequest &request)const;
void describeLiveStreamHistoryUserNumAsync(const Model::DescribeLiveStreamHistoryUserNumRequest& request, const DescribeLiveStreamHistoryUserNumAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamHistoryUserNumOutcomeCallable describeLiveStreamHistoryUserNumCallable(const Model::DescribeLiveStreamHistoryUserNumRequest& request) const;
AddLiveAppRecordConfigOutcome addLiveAppRecordConfig(const Model::AddLiveAppRecordConfigRequest &request)const;
void addLiveAppRecordConfigAsync(const Model::AddLiveAppRecordConfigRequest& request, const AddLiveAppRecordConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveAppRecordConfigOutcomeCallable addLiveAppRecordConfigCallable(const Model::AddLiveAppRecordConfigRequest& request) const;
AddLiveRecordVodConfigOutcome addLiveRecordVodConfig(const Model::AddLiveRecordVodConfigRequest &request)const;
void addLiveRecordVodConfigAsync(const Model::AddLiveRecordVodConfigRequest& request, const AddLiveRecordVodConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveRecordVodConfigOutcomeCallable addLiveRecordVodConfigCallable(const Model::AddLiveRecordVodConfigRequest& request) const;
DescribeLiveStreamRecordIndexFilesOutcome describeLiveStreamRecordIndexFiles(const Model::DescribeLiveStreamRecordIndexFilesRequest &request)const;
void describeLiveStreamRecordIndexFilesAsync(const Model::DescribeLiveStreamRecordIndexFilesRequest& request, const DescribeLiveStreamRecordIndexFilesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamRecordIndexFilesOutcomeCallable describeLiveStreamRecordIndexFilesCallable(const Model::DescribeLiveStreamRecordIndexFilesRequest& request) const;
AddCasterProgramOutcome addCasterProgram(const Model::AddCasterProgramRequest &request)const;
void addCasterProgramAsync(const Model::AddCasterProgramRequest& request, const AddCasterProgramAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddCasterProgramOutcomeCallable addCasterProgramCallable(const Model::AddCasterProgramRequest& request) const;
DeleteLiveMixConfigOutcome deleteLiveMixConfig(const Model::DeleteLiveMixConfigRequest &request)const;
void deleteLiveMixConfigAsync(const Model::DeleteLiveMixConfigRequest& request, const DeleteLiveMixConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveMixConfigOutcomeCallable deleteLiveMixConfigCallable(const Model::DeleteLiveMixConfigRequest& request) const;
ForbidLiveStreamOutcome forbidLiveStream(const Model::ForbidLiveStreamRequest &request)const;
void forbidLiveStreamAsync(const Model::ForbidLiveStreamRequest& request, const ForbidLiveStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ForbidLiveStreamOutcomeCallable forbidLiveStreamCallable(const Model::ForbidLiveStreamRequest& request) const;
DeleteCasterEpisodeGroupOutcome deleteCasterEpisodeGroup(const Model::DeleteCasterEpisodeGroupRequest &request)const;
void deleteCasterEpisodeGroupAsync(const Model::DeleteCasterEpisodeGroupRequest& request, const DeleteCasterEpisodeGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCasterEpisodeGroupOutcomeCallable deleteCasterEpisodeGroupCallable(const Model::DeleteCasterEpisodeGroupRequest& request) const;
DescribeCasterVideoResourcesOutcome describeCasterVideoResources(const Model::DescribeCasterVideoResourcesRequest &request)const;
void describeCasterVideoResourcesAsync(const Model::DescribeCasterVideoResourcesRequest& request, const DescribeCasterVideoResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCasterVideoResourcesOutcomeCallable describeCasterVideoResourcesCallable(const Model::DescribeCasterVideoResourcesRequest& request) const;
UpdateLiveAppSnapshotConfigOutcome updateLiveAppSnapshotConfig(const Model::UpdateLiveAppSnapshotConfigRequest &request)const;
void updateLiveAppSnapshotConfigAsync(const Model::UpdateLiveAppSnapshotConfigRequest& request, const UpdateLiveAppSnapshotConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateLiveAppSnapshotConfigOutcomeCallable updateLiveAppSnapshotConfigCallable(const Model::UpdateLiveAppSnapshotConfigRequest& request) const;
DeleteLiveDetectNotifyConfigOutcome deleteLiveDetectNotifyConfig(const Model::DeleteLiveDetectNotifyConfigRequest &request)const;
void deleteLiveDetectNotifyConfigAsync(const Model::DeleteLiveDetectNotifyConfigRequest& request, const DeleteLiveDetectNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveDetectNotifyConfigOutcomeCallable deleteLiveDetectNotifyConfigCallable(const Model::DeleteLiveDetectNotifyConfigRequest& request) const;
EffectCasterVideoResourceOutcome effectCasterVideoResource(const Model::EffectCasterVideoResourceRequest &request)const;
void effectCasterVideoResourceAsync(const Model::EffectCasterVideoResourceRequest& request, const EffectCasterVideoResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EffectCasterVideoResourceOutcomeCallable effectCasterVideoResourceCallable(const Model::EffectCasterVideoResourceRequest& request) const;
DeleteLiveMixNotifyConfigOutcome deleteLiveMixNotifyConfig(const Model::DeleteLiveMixNotifyConfigRequest &request)const;
void deleteLiveMixNotifyConfigAsync(const Model::DeleteLiveMixNotifyConfigRequest& request, const DeleteLiveMixNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveMixNotifyConfigOutcomeCallable deleteLiveMixNotifyConfigCallable(const Model::DeleteLiveMixNotifyConfigRequest& request) const;
AddLiveAppSnapshotConfigOutcome addLiveAppSnapshotConfig(const Model::AddLiveAppSnapshotConfigRequest &request)const;
void addLiveAppSnapshotConfigAsync(const Model::AddLiveAppSnapshotConfigRequest& request, const AddLiveAppSnapshotConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveAppSnapshotConfigOutcomeCallable addLiveAppSnapshotConfigCallable(const Model::AddLiveAppSnapshotConfigRequest& request) const;
RemoveMultipleStreamMixServiceOutcome removeMultipleStreamMixService(const Model::RemoveMultipleStreamMixServiceRequest &request)const;
void removeMultipleStreamMixServiceAsync(const Model::RemoveMultipleStreamMixServiceRequest& request, const RemoveMultipleStreamMixServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RemoveMultipleStreamMixServiceOutcomeCallable removeMultipleStreamMixServiceCallable(const Model::RemoveMultipleStreamMixServiceRequest& request) const;
DeleteCasterComponentOutcome deleteCasterComponent(const Model::DeleteCasterComponentRequest &request)const;
void deleteCasterComponentAsync(const Model::DeleteCasterComponentRequest& request, const DeleteCasterComponentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCasterComponentOutcomeCallable deleteCasterComponentCallable(const Model::DeleteCasterComponentRequest& request) const;
SetCasterConfigOutcome setCasterConfig(const Model::SetCasterConfigRequest &request)const;
void setCasterConfigAsync(const Model::SetCasterConfigRequest& request, const SetCasterConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetCasterConfigOutcomeCallable setCasterConfigCallable(const Model::SetCasterConfigRequest& request) const;
RealTimeRecordCommandOutcome realTimeRecordCommand(const Model::RealTimeRecordCommandRequest &request)const;
void realTimeRecordCommandAsync(const Model::RealTimeRecordCommandRequest& request, const RealTimeRecordCommandAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RealTimeRecordCommandOutcomeCallable realTimeRecordCommandCallable(const Model::RealTimeRecordCommandRequest& request) const;
StartCasterOutcome startCaster(const Model::StartCasterRequest &request)const;
void startCasterAsync(const Model::StartCasterRequest& request, const StartCasterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StartCasterOutcomeCallable startCasterCallable(const Model::StartCasterRequest& request) const;
ResumeLiveStreamOutcome resumeLiveStream(const Model::ResumeLiveStreamRequest &request)const;
void resumeLiveStreamAsync(const Model::ResumeLiveStreamRequest& request, const ResumeLiveStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ResumeLiveStreamOutcomeCallable resumeLiveStreamCallable(const Model::ResumeLiveStreamRequest& request) const;
AddCasterLayoutOutcome addCasterLayout(const Model::AddCasterLayoutRequest &request)const;
void addCasterLayoutAsync(const Model::AddCasterLayoutRequest& request, const AddCasterLayoutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddCasterLayoutOutcomeCallable addCasterLayoutCallable(const Model::AddCasterLayoutRequest& request) const;
ModifyCasterLayoutOutcome modifyCasterLayout(const Model::ModifyCasterLayoutRequest &request)const;
void modifyCasterLayoutAsync(const Model::ModifyCasterLayoutRequest& request, const ModifyCasterLayoutAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyCasterLayoutOutcomeCallable modifyCasterLayoutCallable(const Model::ModifyCasterLayoutRequest& request) const;
StopCasterOutcome stopCaster(const Model::StopCasterRequest &request)const;
void stopCasterAsync(const Model::StopCasterRequest& request, const StopCasterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
StopCasterOutcomeCallable stopCasterCallable(const Model::StopCasterRequest& request) const;
DescribeLiveStreamsPublishListOutcome describeLiveStreamsPublishList(const Model::DescribeLiveStreamsPublishListRequest &request)const;
void describeLiveStreamsPublishListAsync(const Model::DescribeLiveStreamsPublishListRequest& request, const DescribeLiveStreamsPublishListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamsPublishListOutcomeCallable describeLiveStreamsPublishListCallable(const Model::DescribeLiveStreamsPublishListRequest& request) const;
DescribeLiveSnapshotDetectPornConfigOutcome describeLiveSnapshotDetectPornConfig(const Model::DescribeLiveSnapshotDetectPornConfigRequest &request)const;
void describeLiveSnapshotDetectPornConfigAsync(const Model::DescribeLiveSnapshotDetectPornConfigRequest& request, const DescribeLiveSnapshotDetectPornConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveSnapshotDetectPornConfigOutcomeCallable describeLiveSnapshotDetectPornConfigCallable(const Model::DescribeLiveSnapshotDetectPornConfigRequest& request) const;
DeleteCasterSceneConfigOutcome deleteCasterSceneConfig(const Model::DeleteCasterSceneConfigRequest &request)const;
void deleteCasterSceneConfigAsync(const Model::DeleteCasterSceneConfigRequest& request, const DeleteCasterSceneConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCasterSceneConfigOutcomeCallable deleteCasterSceneConfigCallable(const Model::DeleteCasterSceneConfigRequest& request) const;
DeleteLiveAppRecordConfigOutcome deleteLiveAppRecordConfig(const Model::DeleteLiveAppRecordConfigRequest &request)const;
void deleteLiveAppRecordConfigAsync(const Model::DeleteLiveAppRecordConfigRequest& request, const DeleteLiveAppRecordConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveAppRecordConfigOutcomeCallable deleteLiveAppRecordConfigCallable(const Model::DeleteLiveAppRecordConfigRequest& request) const;
DeleteCasterOutcome deleteCaster(const Model::DeleteCasterRequest &request)const;
void deleteCasterAsync(const Model::DeleteCasterRequest& request, const DeleteCasterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCasterOutcomeCallable deleteCasterCallable(const Model::DeleteCasterRequest& request) const;
DescribeLiveRecordVodConfigsOutcome describeLiveRecordVodConfigs(const Model::DescribeLiveRecordVodConfigsRequest &request)const;
void describeLiveRecordVodConfigsAsync(const Model::DescribeLiveRecordVodConfigsRequest& request, const DescribeLiveRecordVodConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveRecordVodConfigsOutcomeCallable describeLiveRecordVodConfigsCallable(const Model::DescribeLiveRecordVodConfigsRequest& request) const;
DescribeCastersOutcome describeCasters(const Model::DescribeCastersRequest &request)const;
void describeCastersAsync(const Model::DescribeCastersRequest& request, const DescribeCastersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCastersOutcomeCallable describeCastersCallable(const Model::DescribeCastersRequest& request) const;
AddLiveMixNotifyConfigOutcome addLiveMixNotifyConfig(const Model::AddLiveMixNotifyConfigRequest &request)const;
void addLiveMixNotifyConfigAsync(const Model::AddLiveMixNotifyConfigRequest& request, const AddLiveMixNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveMixNotifyConfigOutcomeCallable addLiveMixNotifyConfigCallable(const Model::AddLiveMixNotifyConfigRequest& request) const;
AddLiveDetectNotifyConfigOutcome addLiveDetectNotifyConfig(const Model::AddLiveDetectNotifyConfigRequest &request)const;
void addLiveDetectNotifyConfigAsync(const Model::AddLiveDetectNotifyConfigRequest& request, const AddLiveDetectNotifyConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AddLiveDetectNotifyConfigOutcomeCallable addLiveDetectNotifyConfigCallable(const Model::AddLiveDetectNotifyConfigRequest& request) const;
DescribeCasterScenesOutcome describeCasterScenes(const Model::DescribeCasterScenesRequest &request)const;
void describeCasterScenesAsync(const Model::DescribeCasterScenesRequest& request, const DescribeCasterScenesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCasterScenesOutcomeCallable describeCasterScenesCallable(const Model::DescribeCasterScenesRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_LIVE_LIVECLIENT_H_

32
live/include/alibabacloud/live/LiveExport.h Normal file
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_LIVE_LIVEEXPORT_H_
#define ALIBABACLOUD_LIVE_LIVEEXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_LIVE_LIBRARY)
# define ALIBABACLOUD_LIVE_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_LIVE_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_LIVE_EXPORT
#endif
#endif // !ALIBABACLOUD_LIVE_LIVEEXPORT_H_

75
live/include/alibabacloud/live/model/AddCasterComponentRequest.h Normal file
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_LIVE_MODEL_ADDCASTERCOMPONENTREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTERCOMPONENTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterComponentRequest : public RpcServiceRequest
{
public:
AddCasterComponentRequest();
~AddCasterComponentRequest();
std::string getComponentType()const;
void setComponentType(const std::string& componentType);
std::string getLocationId()const;
void setLocationId(const std::string& locationId);
std::string getImageLayerContent()const;
void setImageLayerContent(const std::string& imageLayerContent);
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
std::string getEffect()const;
void setEffect(const std::string& effect);
std::string getComponentLayer()const;
void setComponentLayer(const std::string& componentLayer);
std::string getCaptionLayerContent()const;
void setCaptionLayerContent(const std::string& captionLayerContent);
std::string getComponentName()const;
void setComponentName(const std::string& componentName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTextLayerContent()const;
void setTextLayerContent(const std::string& textLayerContent);
private:
std::string componentType_;
std::string locationId_;
std::string imageLayerContent_;
std::string casterId_;
std::string effect_;
std::string componentLayer_;
std::string captionLayerContent_;
std::string componentName_;
long ownerId_;
std::string textLayerContent_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTERCOMPONENTREQUEST_H_

51
live/include/alibabacloud/live/model/AddCasterComponentResult.h Normal file
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_LIVE_MODEL_ADDCASTERCOMPONENTRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTERCOMPONENTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterComponentResult : public ServiceResult
{
public:
AddCasterComponentResult();
explicit AddCasterComponentResult(const std::string &payload);
~AddCasterComponentResult();
std::string getComponentId()const;
protected:
void parse(const std::string &payload);
private:
std::string componentId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTERCOMPONENTRESULT_H_

54
live/include/alibabacloud/live/model/AddCasterEpisodeGroupContentRequest.h Normal file
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_LIVE_MODEL_ADDCASTEREPISODEGROUPCONTENTREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODEGROUPCONTENTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterEpisodeGroupContentRequest : public RpcServiceRequest
{
public:
AddCasterEpisodeGroupContentRequest();
~AddCasterEpisodeGroupContentRequest();
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getContent()const;
void setContent(const std::string& content);
private:
std::string clientToken_;
long ownerId_;
std::string content_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODEGROUPCONTENTREQUEST_H_

53
live/include/alibabacloud/live/model/AddCasterEpisodeGroupContentResult.h Normal file
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_LIVE_MODEL_ADDCASTEREPISODEGROUPCONTENTRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODEGROUPCONTENTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterEpisodeGroupContentResult : public ServiceResult
{
public:
AddCasterEpisodeGroupContentResult();
explicit AddCasterEpisodeGroupContentResult(const std::string &payload);
~AddCasterEpisodeGroupContentResult();
std::string getProgramId()const;
std::vector<std::string> getItemIds()const;
protected:
void parse(const std::string &payload);
private:
std::string programId_;
std::vector<std::string> itemIds_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODEGROUPCONTENTRESULT_H_

74
live/include/alibabacloud/live/model/AddCasterEpisodeGroupRequest.h Normal file
View File

@@ -0,0 +1,74 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODEGROUPREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODEGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterEpisodeGroupRequest : public RpcServiceRequest
{
struct Item
{
std::string itemName;
std::string vodUrl;
};
public:
AddCasterEpisodeGroupRequest();
~AddCasterEpisodeGroupRequest();
std::string getSideOutputUrl()const;
void setSideOutputUrl(const std::string& sideOutputUrl);
std::vector<Item> getItem()const;
void setItem(const std::vector<Item>& item);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
int getRepeatNum()const;
void setRepeatNum(int repeatNum);
std::string getCallbackUrl()const;
void setCallbackUrl(const std::string& callbackUrl);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string sideOutputUrl_;
std::vector<Item> item_;
std::string clientToken_;
std::string domainName_;
std::string startTime_;
int repeatNum_;
std::string callbackUrl_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODEGROUPREQUEST_H_

53
live/include/alibabacloud/live/model/AddCasterEpisodeGroupResult.h Normal file
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_LIVE_MODEL_ADDCASTEREPISODEGROUPRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODEGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterEpisodeGroupResult : public ServiceResult
{
public:
AddCasterEpisodeGroupResult();
explicit AddCasterEpisodeGroupResult(const std::string &payload);
~AddCasterEpisodeGroupResult();
std::string getProgramId()const;
std::vector<std::string> getItemIds()const;
protected:
void parse(const std::string &payload);
private:
std::string programId_;
std::vector<std::string> itemIds_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODEGROUPRESULT_H_

72
live/include/alibabacloud/live/model/AddCasterEpisodeRequest.h Normal file
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_LIVE_MODEL_ADDCASTEREPISODEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterEpisodeRequest : public RpcServiceRequest
{
public:
AddCasterEpisodeRequest();
~AddCasterEpisodeRequest();
std::string getResourceId()const;
void setResourceId(const std::string& resourceId);
std::vector<std::string> getComponentId()const;
void setComponentId(const std::vector<std::string>& componentId);
std::string getSwitchType()const;
void setSwitchType(const std::string& switchType);
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
std::string getEpisodeType()const;
void setEpisodeType(const std::string& episodeType);
std::string getEpisodeName()const;
void setEpisodeName(const std::string& episodeName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string resourceId_;
std::vector<std::string> componentId_;
std::string switchType_;
std::string casterId_;
std::string episodeType_;
std::string episodeName_;
std::string endTime_;
std::string startTime_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODEREQUEST_H_

51
live/include/alibabacloud/live/model/AddCasterEpisodeResult.h Normal file
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_LIVE_MODEL_ADDCASTEREPISODERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterEpisodeResult : public ServiceResult
{
public:
AddCasterEpisodeResult();
explicit AddCasterEpisodeResult(const std::string &payload);
~AddCasterEpisodeResult();
std::string getEpisodeId()const;
protected:
void parse(const std::string &payload);
private:
std::string episodeId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTEREPISODERESULT_H_

78
live/include/alibabacloud/live/model/AddCasterLayoutRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_ADDCASTERLAYOUTREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTERLAYOUTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterLayoutRequest : public RpcServiceRequest
{
struct AudioLayer
{
float volumeRate;
std::string validChannel;
int fixedDelayDuration;
};
struct VideoLayer
{
std::string fillMode;
float heightNormalized;
float widthNormalized;
std::string positionRefer;
std::vector<float> positionNormalized;
int fixedDelayDuration;
};
public:
AddCasterLayoutRequest();
~AddCasterLayoutRequest();
std::vector<std::string> getBlendList()const;
void setBlendList(const std::vector<std::string>& blendList);
std::vector<AudioLayer> getAudioLayer()const;
void setAudioLayer(const std::vector<AudioLayer>& audioLayer);
std::vector<VideoLayer> getVideoLayer()const;
void setVideoLayer(const std::vector<VideoLayer>& videoLayer);
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
std::vector<std::string> getMixList()const;
void setMixList(const std::vector<std::string>& mixList);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::vector<std::string> blendList_;
std::vector<AudioLayer> audioLayer_;
std::vector<VideoLayer> videoLayer_;
std::string casterId_;
std::vector<std::string> mixList_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTERLAYOUTREQUEST_H_

51
live/include/alibabacloud/live/model/AddCasterLayoutResult.h Normal file
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_LIVE_MODEL_ADDCASTERLAYOUTRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTERLAYOUTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterLayoutResult : public ServiceResult
{
public:
AddCasterLayoutResult();
explicit AddCasterLayoutResult(const std::string &payload);
~AddCasterLayoutResult();
std::string getLayoutId()const;
protected:
void parse(const std::string &payload);
private:
std::string layoutId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTERLAYOUTRESULT_H_

64
live/include/alibabacloud/live/model/AddCasterProgramRequest.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_ADDCASTERPROGRAMREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTERPROGRAMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterProgramRequest : public RpcServiceRequest
{
struct Episode
{
std::string episodeType;
std::string episodeName;
std::string resourceId;
std::vector<std::string> componentId;
std::string startTime;
std::string endTime;
std::string switchType;
};
public:
AddCasterProgramRequest();
~AddCasterProgramRequest();
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
std::vector<Episode> getEpisode()const;
void setEpisode(const std::vector<Episode>& episode);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string casterId_;
std::vector<Episode> episode_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTERPROGRAMREQUEST_H_

55
live/include/alibabacloud/live/model/AddCasterProgramResult.h Normal file
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_LIVE_MODEL_ADDCASTERPROGRAMRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTERPROGRAMRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterProgramResult : public ServiceResult
{
public:
struct EpisodeId
{
std::string episodeId;
};
AddCasterProgramResult();
explicit AddCasterProgramResult(const std::string &payload);
~AddCasterProgramResult();
std::vector<EpisodeId> getEpisodeIds()const;
protected:
void parse(const std::string &payload);
private:
std::vector<EpisodeId> episodeIds_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTERPROGRAMRESULT_H_

75
live/include/alibabacloud/live/model/AddCasterVideoResourceRequest.h Normal file
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_LIVE_MODEL_ADDCASTERVIDEORESOURCEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTERVIDEORESOURCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterVideoResourceRequest : public RpcServiceRequest
{
public:
AddCasterVideoResourceRequest();
~AddCasterVideoResourceRequest();
int getBeginOffset()const;
void setBeginOffset(int beginOffset);
std::string getVodUrl()const;
void setVodUrl(const std::string& vodUrl);
std::string getLiveStreamUrl()const;
void setLiveStreamUrl(const std::string& liveStreamUrl);
std::string getLocationId()const;
void setLocationId(const std::string& locationId);
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
int getEndOffset()const;
void setEndOffset(int endOffset);
std::string getResourceName()const;
void setResourceName(const std::string& resourceName);
int getRepeatNum()const;
void setRepeatNum(int repeatNum);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getMaterialId()const;
void setMaterialId(const std::string& materialId);
private:
int beginOffset_;
std::string vodUrl_;
std::string liveStreamUrl_;
std::string locationId_;
std::string casterId_;
int endOffset_;
std::string resourceName_;
int repeatNum_;
long ownerId_;
std::string materialId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTERVIDEORESOURCEREQUEST_H_

51
live/include/alibabacloud/live/model/AddCasterVideoResourceResult.h Normal file
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_LIVE_MODEL_ADDCASTERVIDEORESOURCERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCASTERVIDEORESOURCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCasterVideoResourceResult : public ServiceResult
{
public:
AddCasterVideoResourceResult();
explicit AddCasterVideoResourceResult(const std::string &payload);
~AddCasterVideoResourceResult();
std::string getResourceId()const;
protected:
void parse(const std::string &payload);
private:
std::string resourceId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCASTERVIDEORESOURCERESULT_H_

81
live/include/alibabacloud/live/model/AddCustomLiveStreamTranscodeRequest.h Normal file
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_LIVE_MODEL_ADDCUSTOMLIVESTREAMTRANSCODEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCUSTOMLIVESTREAMTRANSCODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCustomLiveStreamTranscodeRequest : public RpcServiceRequest
{
public:
AddCustomLiveStreamTranscodeRequest();
~AddCustomLiveStreamTranscodeRequest();
std::string getApp()const;
void setApp(const std::string& app);
std::string get_Template()const;
void set_Template(const std::string& _template);
int getFPS()const;
void setFPS(int fPS);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getVersion()const;
void setVersion(const std::string& version);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getTemplateType()const;
void setTemplateType(const std::string& templateType);
std::string getDomain()const;
void setDomain(const std::string& domain);
int getWidth()const;
void setWidth(int width);
int getVideoBitrate()const;
void setVideoBitrate(int videoBitrate);
int getHeight()const;
void setHeight(int height);
private:
std::string app_;
std::string _template_;
int fPS_;
long ownerId_;
std::string version_;
std::string accessKeyId_;
std::string securityToken_;
std::string templateType_;
std::string domain_;
int width_;
int videoBitrate_;
int height_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCUSTOMLIVESTREAMTRANSCODEREQUEST_H_

49
live/include/alibabacloud/live/model/AddCustomLiveStreamTranscodeResult.h Normal file
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_LIVE_MODEL_ADDCUSTOMLIVESTREAMTRANSCODERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDCUSTOMLIVESTREAMTRANSCODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddCustomLiveStreamTranscodeResult : public ServiceResult
{
public:
AddCustomLiveStreamTranscodeResult();
explicit AddCustomLiveStreamTranscodeResult(const std::string &payload);
~AddCustomLiveStreamTranscodeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDCUSTOMLIVESTREAMTRANSCODERESULT_H_

88
live/include/alibabacloud/live/model/AddLiveAppRecordConfigRequest.h Normal file
View File

@@ -0,0 +1,88 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_ADDLIVEAPPRECORDCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEAPPRECORDCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveAppRecordConfigRequest : public RpcServiceRequest
{
struct RecordFormat
{
std::string format;
std::string ossObjectPrefix;
std::string sliceOssObjectPrefix;
int cycleDuration;
};
public:
AddLiveAppRecordConfigRequest();
~AddLiveAppRecordConfigRequest();
std::string getOssBucket()const;
void setOssBucket(const std::string& ossBucket);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getOssEndpoint()const;
void setOssEndpoint(const std::string& ossEndpoint);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::vector<RecordFormat> getRecordFormat()const;
void setRecordFormat(const std::vector<RecordFormat>& recordFormat);
int getOnDemand()const;
void setOnDemand(int onDemand);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
private:
std::string ossBucket_;
std::string domainName_;
std::string ossEndpoint_;
std::string endTime_;
std::string startTime_;
long ownerId_;
std::string accessKeyId_;
std::string appName_;
std::string securityToken_;
std::vector<RecordFormat> recordFormat_;
int onDemand_;
std::string streamName_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEAPPRECORDCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/AddLiveAppRecordConfigResult.h Normal file
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_LIVE_MODEL_ADDLIVEAPPRECORDCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEAPPRECORDCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveAppRecordConfigResult : public ServiceResult
{
public:
AddLiveAppRecordConfigResult();
explicit AddLiveAppRecordConfigResult(const std::string &payload);
~AddLiveAppRecordConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEAPPRECORDCONFIGRESULT_H_

75
live/include/alibabacloud/live/model/AddLiveAppSnapshotConfigRequest.h Normal file
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_LIVE_MODEL_ADDLIVEAPPSNAPSHOTCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEAPPSNAPSHOTCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveAppSnapshotConfigRequest : public RpcServiceRequest
{
public:
AddLiveAppSnapshotConfigRequest();
~AddLiveAppSnapshotConfigRequest();
int getTimeInterval()const;
void setTimeInterval(int timeInterval);
std::string getOssBucket()const;
void setOssBucket(const std::string& ossBucket);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getOssEndpoint()const;
void setOssEndpoint(const std::string& ossEndpoint);
std::string getSequenceOssObject()const;
void setSequenceOssObject(const std::string& sequenceOssObject);
std::string getOverwriteOssObject()const;
void setOverwriteOssObject(const std::string& overwriteOssObject);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
int timeInterval_;
std::string ossBucket_;
std::string appName_;
std::string securityToken_;
std::string domainName_;
std::string ossEndpoint_;
std::string sequenceOssObject_;
std::string overwriteOssObject_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEAPPSNAPSHOTCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/AddLiveAppSnapshotConfigResult.h Normal file
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_LIVE_MODEL_ADDLIVEAPPSNAPSHOTCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEAPPSNAPSHOTCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveAppSnapshotConfigResult : public ServiceResult
{
public:
AddLiveAppSnapshotConfigResult();
explicit AddLiveAppSnapshotConfigResult(const std::string &payload);
~AddLiveAppSnapshotConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEAPPSNAPSHOTCONFIGRESULT_H_

60
live/include/alibabacloud/live/model/AddLiveDetectNotifyConfigRequest.h Normal file
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_LIVE_MODEL_ADDLIVEDETECTNOTIFYCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEDETECTNOTIFYCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveDetectNotifyConfigRequest : public RpcServiceRequest
{
public:
AddLiveDetectNotifyConfigRequest();
~AddLiveDetectNotifyConfigRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getNotifyUrl()const;
void setNotifyUrl(const std::string& notifyUrl);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string domainName_;
std::string notifyUrl_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEDETECTNOTIFYCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/AddLiveDetectNotifyConfigResult.h Normal file
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_LIVE_MODEL_ADDLIVEDETECTNOTIFYCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEDETECTNOTIFYCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveDetectNotifyConfigResult : public ServiceResult
{
public:
AddLiveDetectNotifyConfigResult();
explicit AddLiveDetectNotifyConfigResult(const std::string &payload);
~AddLiveDetectNotifyConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEDETECTNOTIFYCONFIGRESULT_H_

63
live/include/alibabacloud/live/model/AddLiveMixConfigRequest.h Normal file
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_LIVE_MODEL_ADDLIVEMIXCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEMIXCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveMixConfigRequest : public RpcServiceRequest
{
public:
AddLiveMixConfigRequest();
~AddLiveMixConfigRequest();
std::string get_Template()const;
void set_Template(const std::string& _template);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string _template_;
std::string appName_;
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEMIXCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/AddLiveMixConfigResult.h Normal file
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_LIVE_MODEL_ADDLIVEMIXCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEMIXCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveMixConfigResult : public ServiceResult
{
public:
AddLiveMixConfigResult();
explicit AddLiveMixConfigResult(const std::string &payload);
~AddLiveMixConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEMIXCONFIGRESULT_H_

60
live/include/alibabacloud/live/model/AddLiveMixNotifyConfigRequest.h Normal file
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_LIVE_MODEL_ADDLIVEMIXNOTIFYCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEMIXNOTIFYCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveMixNotifyConfigRequest : public RpcServiceRequest
{
public:
AddLiveMixNotifyConfigRequest();
~AddLiveMixNotifyConfigRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getNotifyUrl()const;
void setNotifyUrl(const std::string& notifyUrl);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string domainName_;
std::string notifyUrl_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEMIXNOTIFYCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/AddLiveMixNotifyConfigResult.h Normal file
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_LIVE_MODEL_ADDLIVEMIXNOTIFYCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEMIXNOTIFYCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveMixNotifyConfigResult : public ServiceResult
{
public:
AddLiveMixNotifyConfigResult();
explicit AddLiveMixNotifyConfigResult(const std::string &payload);
~AddLiveMixNotifyConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEMIXNOTIFYCONFIGRESULT_H_

72
live/include/alibabacloud/live/model/AddLivePullStreamInfoConfigRequest.h Normal file
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_LIVE_MODEL_ADDLIVEPULLSTREAMINFOCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEPULLSTREAMINFOCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLivePullStreamInfoConfigRequest : public RpcServiceRequest
{
public:
AddLivePullStreamInfoConfigRequest();
~AddLivePullStreamInfoConfigRequest();
std::string getSourceUrl()const;
void setSourceUrl(const std::string& sourceUrl);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string sourceUrl_;
std::string appName_;
std::string securityToken_;
std::string domainName_;
std::string endTime_;
std::string startTime_;
long ownerId_;
std::string streamName_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEPULLSTREAMINFOCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/AddLivePullStreamInfoConfigResult.h Normal file
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_LIVE_MODEL_ADDLIVEPULLSTREAMINFOCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVEPULLSTREAMINFOCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLivePullStreamInfoConfigResult : public ServiceResult
{
public:
AddLivePullStreamInfoConfigResult();
explicit AddLivePullStreamInfoConfigResult(const std::string &payload);
~AddLivePullStreamInfoConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVEPULLSTREAMINFOCONFIGRESULT_H_

66
live/include/alibabacloud/live/model/AddLiveRecordNotifyConfigRequest.h Normal file
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_LIVE_MODEL_ADDLIVERECORDNOTIFYCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVERECORDNOTIFYCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveRecordNotifyConfigRequest : public RpcServiceRequest
{
public:
AddLiveRecordNotifyConfigRequest();
~AddLiveRecordNotifyConfigRequest();
std::string getOnDemandUrl()const;
void setOnDemandUrl(const std::string& onDemandUrl);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getNotifyUrl()const;
void setNotifyUrl(const std::string& notifyUrl);
long getOwnerId()const;
void setOwnerId(long ownerId);
bool getNeedStatusNotify()const;
void setNeedStatusNotify(bool needStatusNotify);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string onDemandUrl_;
std::string securityToken_;
std::string domainName_;
std::string notifyUrl_;
long ownerId_;
bool needStatusNotify_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVERECORDNOTIFYCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/AddLiveRecordNotifyConfigResult.h Normal file
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_LIVE_MODEL_ADDLIVERECORDNOTIFYCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVERECORDNOTIFYCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveRecordNotifyConfigResult : public ServiceResult
{
public:
AddLiveRecordNotifyConfigResult();
explicit AddLiveRecordNotifyConfigResult(const std::string &payload);
~AddLiveRecordNotifyConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVERECORDNOTIFYCONFIGRESULT_H_

69
live/include/alibabacloud/live/model/AddLiveRecordVodConfigRequest.h Normal file
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_LIVE_MODEL_ADDLIVERECORDVODCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVERECORDVODCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveRecordVodConfigRequest : public RpcServiceRequest
{
public:
AddLiveRecordVodConfigRequest();
~AddLiveRecordVodConfigRequest();
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getAutoCompose()const;
void setAutoCompose(const std::string& autoCompose);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
int getCycleDuration()const;
void setCycleDuration(int cycleDuration);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getComposeVodTranscodeGroupId()const;
void setComposeVodTranscodeGroupId(const std::string& composeVodTranscodeGroupId);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getVodTranscodeGroupId()const;
void setVodTranscodeGroupId(const std::string& vodTranscodeGroupId);
private:
std::string appName_;
std::string autoCompose_;
std::string domainName_;
int cycleDuration_;
long ownerId_;
std::string composeVodTranscodeGroupId_;
std::string streamName_;
std::string vodTranscodeGroupId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVERECORDVODCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/AddLiveRecordVodConfigResult.h Normal file
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_LIVE_MODEL_ADDLIVERECORDVODCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVERECORDVODCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveRecordVodConfigResult : public ServiceResult
{
public:
AddLiveRecordVodConfigResult();
explicit AddLiveRecordVodConfigResult(const std::string &payload);
~AddLiveRecordVodConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVERECORDVODCONFIGRESULT_H_

75
live/include/alibabacloud/live/model/AddLiveSnapshotDetectPornConfigRequest.h Normal file
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_LIVE_MODEL_ADDLIVESNAPSHOTDETECTPORNCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVESNAPSHOTDETECTPORNCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveSnapshotDetectPornConfigRequest : public RpcServiceRequest
{
public:
AddLiveSnapshotDetectPornConfigRequest();
~AddLiveSnapshotDetectPornConfigRequest();
std::string getOssBucket()const;
void setOssBucket(const std::string& ossBucket);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getOssEndpoint()const;
void setOssEndpoint(const std::string& ossEndpoint);
int getInterval()const;
void setInterval(int interval);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getOssObject()const;
void setOssObject(const std::string& ossObject);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::vector<std::string> getScene()const;
void setScene(const std::vector<std::string>& scene);
private:
std::string ossBucket_;
std::string appName_;
std::string securityToken_;
std::string domainName_;
std::string ossEndpoint_;
int interval_;
long ownerId_;
std::string ossObject_;
std::string accessKeyId_;
std::vector<std::string> scene_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVESNAPSHOTDETECTPORNCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/AddLiveSnapshotDetectPornConfigResult.h Normal file
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_LIVE_MODEL_ADDLIVESNAPSHOTDETECTPORNCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVESNAPSHOTDETECTPORNCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveSnapshotDetectPornConfigResult : public ServiceResult
{
public:
AddLiveSnapshotDetectPornConfigResult();
explicit AddLiveSnapshotDetectPornConfigResult(const std::string &payload);
~AddLiveSnapshotDetectPornConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVESNAPSHOTDETECTPORNCONFIGRESULT_H_

63
live/include/alibabacloud/live/model/AddLiveStreamTranscodeRequest.h Normal file
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_LIVE_MODEL_ADDLIVESTREAMTRANSCODEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMTRANSCODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveStreamTranscodeRequest : public RpcServiceRequest
{
public:
AddLiveStreamTranscodeRequest();
~AddLiveStreamTranscodeRequest();
std::string getApp()const;
void setApp(const std::string& app);
std::string get_Template()const;
void set_Template(const std::string& _template);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomain()const;
void setDomain(const std::string& domain);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string app_;
std::string _template_;
std::string securityToken_;
std::string domain_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMTRANSCODEREQUEST_H_

49
live/include/alibabacloud/live/model/AddLiveStreamTranscodeResult.h Normal file
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_LIVE_MODEL_ADDLIVESTREAMTRANSCODERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMTRANSCODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddLiveStreamTranscodeResult : public ServiceResult
{
public:
AddLiveStreamTranscodeResult();
explicit AddLiveStreamTranscodeResult(const std::string &payload);
~AddLiveStreamTranscodeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDLIVESTREAMTRANSCODERESULT_H_

72
live/include/alibabacloud/live/model/AddMultipleStreamMixServiceRequest.h Normal file
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_LIVE_MODEL_ADDMULTIPLESTREAMMIXSERVICEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDMULTIPLESTREAMMIXSERVICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddMultipleStreamMixServiceRequest : public RpcServiceRequest
{
public:
AddMultipleStreamMixServiceRequest();
~AddMultipleStreamMixServiceRequest();
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getMixStreamName()const;
void setMixStreamName(const std::string& mixStreamName);
std::string getMixDomainName()const;
void setMixDomainName(const std::string& mixDomainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getMixAppName()const;
void setMixAppName(const std::string& mixAppName);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string appName_;
std::string securityToken_;
std::string domainName_;
std::string mixStreamName_;
std::string mixDomainName_;
long ownerId_;
std::string mixAppName_;
std::string streamName_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDMULTIPLESTREAMMIXSERVICEREQUEST_H_

49
live/include/alibabacloud/live/model/AddMultipleStreamMixServiceResult.h Normal file
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_LIVE_MODEL_ADDMULTIPLESTREAMMIXSERVICERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDMULTIPLESTREAMMIXSERVICERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddMultipleStreamMixServiceResult : public ServiceResult
{
public:
AddMultipleStreamMixServiceResult();
explicit AddMultipleStreamMixServiceResult(const std::string &payload);
~AddMultipleStreamMixServiceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDMULTIPLESTREAMMIXSERVICERESULT_H_

69
live/include/alibabacloud/live/model/AddTrancodeSEIRequest.h Normal file
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_LIVE_MODEL_ADDTRANCODESEIREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDTRANCODESEIREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddTrancodeSEIRequest : public RpcServiceRequest
{
public:
AddTrancodeSEIRequest();
~AddTrancodeSEIRequest();
int getDelay()const;
void setDelay(int delay);
std::string getAppName()const;
void setAppName(const std::string& appName);
int getRepeat()const;
void setRepeat(int repeat);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getPattern()const;
void setPattern(const std::string& pattern);
std::string getText()const;
void setText(const std::string& text);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
private:
int delay_;
std::string appName_;
int repeat_;
std::string domainName_;
std::string pattern_;
std::string text_;
long ownerId_;
std::string streamName_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDTRANCODESEIREQUEST_H_

49
live/include/alibabacloud/live/model/AddTrancodeSEIResult.h Normal file
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_LIVE_MODEL_ADDTRANCODESEIRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_ADDTRANCODESEIRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT AddTrancodeSEIResult : public ServiceResult
{
public:
AddTrancodeSEIResult();
explicit AddTrancodeSEIResult(const std::string &payload);
~AddTrancodeSEIResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_ADDTRANCODESEIRESULT_H_

57
live/include/alibabacloud/live/model/CopyCasterRequest.h Normal file
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_LIVE_MODEL_COPYCASTERREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_COPYCASTERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT CopyCasterRequest : public RpcServiceRequest
{
public:
CopyCasterRequest();
~CopyCasterRequest();
std::string getSrcCasterId()const;
void setSrcCasterId(const std::string& srcCasterId);
std::string getCasterName()const;
void setCasterName(const std::string& casterName);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string srcCasterId_;
std::string casterName_;
std::string clientToken_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_COPYCASTERREQUEST_H_

51
live/include/alibabacloud/live/model/CopyCasterResult.h Normal file
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_LIVE_MODEL_COPYCASTERRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_COPYCASTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT CopyCasterResult : public ServiceResult
{
public:
CopyCasterResult();
explicit CopyCasterResult(const std::string &payload);
~CopyCasterResult();
std::string getCasterId()const;
protected:
void parse(const std::string &payload);
private:
std::string casterId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_COPYCASTERRESULT_H_

57
live/include/alibabacloud/live/model/CopyCasterSceneConfigRequest.h Normal file
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_LIVE_MODEL_COPYCASTERSCENECONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_COPYCASTERSCENECONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT CopyCasterSceneConfigRequest : public RpcServiceRequest
{
public:
CopyCasterSceneConfigRequest();
~CopyCasterSceneConfigRequest();
std::string getFromSceneId()const;
void setFromSceneId(const std::string& fromSceneId);
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getToSceneId()const;
void setToSceneId(const std::string& toSceneId);
private:
std::string fromSceneId_;
std::string casterId_;
long ownerId_;
std::string toSceneId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_COPYCASTERSCENECONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/CopyCasterSceneConfigResult.h Normal file
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_LIVE_MODEL_COPYCASTERSCENECONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_COPYCASTERSCENECONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT CopyCasterSceneConfigResult : public ServiceResult
{
public:
CopyCasterSceneConfigResult();
explicit CopyCasterSceneConfigResult(const std::string &payload);
~CopyCasterSceneConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_COPYCASTERSCENECONFIGRESULT_H_

69
live/include/alibabacloud/live/model/CreateCasterRequest.h Normal file
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_LIVE_MODEL_CREATECASTERREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_CREATECASTERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT CreateCasterRequest : public RpcServiceRequest
{
public:
CreateCasterRequest();
~CreateCasterRequest();
std::string getCasterTemplate()const;
void setCasterTemplate(const std::string& casterTemplate);
std::string getExpireTime()const;
void setExpireTime(const std::string& expireTime);
int getNormType()const;
void setNormType(int normType);
std::string getCasterName()const;
void setCasterName(const std::string& casterName);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getChargeType()const;
void setChargeType(const std::string& chargeType);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getPurchaseTime()const;
void setPurchaseTime(const std::string& purchaseTime);
private:
std::string casterTemplate_;
std::string expireTime_;
int normType_;
std::string casterName_;
std::string clientToken_;
std::string chargeType_;
long ownerId_;
std::string purchaseTime_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_CREATECASTERREQUEST_H_

51
live/include/alibabacloud/live/model/CreateCasterResult.h Normal file
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_LIVE_MODEL_CREATECASTERRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_CREATECASTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT CreateCasterResult : public ServiceResult
{
public:
CreateCasterResult();
explicit CreateCasterResult(const std::string &payload);
~CreateCasterResult();
std::string getCasterId()const;
protected:
void parse(const std::string &payload);
private:
std::string casterId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_CREATECASTERRESULT_H_

78
live/include/alibabacloud/live/model/CreateLiveStreamRecordIndexFilesRequest.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_CREATELIVESTREAMRECORDINDEXFILESREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_CREATELIVESTREAMRECORDINDEXFILESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT CreateLiveStreamRecordIndexFilesRequest : public RpcServiceRequest
{
public:
CreateLiveStreamRecordIndexFilesRequest();
~CreateLiveStreamRecordIndexFilesRequest();
std::string getOssBucket()const;
void setOssBucket(const std::string& ossBucket);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
std::string getOssEndpoint()const;
void setOssEndpoint(const std::string& ossEndpoint);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getOssObject()const;
void setOssObject(const std::string& ossObject);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string ossBucket_;
std::string appName_;
std::string securityToken_;
std::string domainName_;
std::string ossEndpoint_;
std::string endTime_;
std::string startTime_;
long ownerId_;
std::string streamName_;
std::string ossObject_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_CREATELIVESTREAMRECORDINDEXFILESREQUEST_H_

68
live/include/alibabacloud/live/model/CreateLiveStreamRecordIndexFilesResult.h Normal file
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_LIVE_MODEL_CREATELIVESTREAMRECORDINDEXFILESRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_CREATELIVESTREAMRECORDINDEXFILESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT CreateLiveStreamRecordIndexFilesResult : public ServiceResult
{
public:
struct RecordInfo
{
std::string endTime;
std::string domainName;
std::string createTime;
std::string ossBucket;
std::string startTime;
float duration;
std::string appName;
std::string streamName;
std::string recordUrl;
std::string ossEndpoint;
std::string ossObject;
int height;
std::string recordId;
int width;
};
CreateLiveStreamRecordIndexFilesResult();
explicit CreateLiveStreamRecordIndexFilesResult(const std::string &payload);
~CreateLiveStreamRecordIndexFilesResult();
RecordInfo getRecordInfo()const;
protected:
void parse(const std::string &payload);
private:
RecordInfo recordInfo_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_CREATELIVESTREAMRECORDINDEXFILESRESULT_H_

54
live/include/alibabacloud/live/model/DeleteCasterComponentRequest.h Normal file
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_LIVE_MODEL_DELETECASTERCOMPONENTREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERCOMPONENTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterComponentRequest : public RpcServiceRequest
{
public:
DeleteCasterComponentRequest();
~DeleteCasterComponentRequest();
std::string getComponentId()const;
void setComponentId(const std::string& componentId);
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string componentId_;
std::string casterId_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERCOMPONENTREQUEST_H_

53
live/include/alibabacloud/live/model/DeleteCasterComponentResult.h Normal file
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_LIVE_MODEL_DELETECASTERCOMPONENTRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERCOMPONENTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterComponentResult : public ServiceResult
{
public:
DeleteCasterComponentResult();
explicit DeleteCasterComponentResult(const std::string &payload);
~DeleteCasterComponentResult();
std::string getCasterId()const;
std::string getComponentId()const;
protected:
void parse(const std::string &payload);
private:
std::string casterId_;
std::string componentId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERCOMPONENTRESULT_H_

51
live/include/alibabacloud/live/model/DeleteCasterEpisodeGroupRequest.h Normal file
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_LIVE_MODEL_DELETECASTEREPISODEGROUPREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTEREPISODEGROUPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterEpisodeGroupRequest : public RpcServiceRequest
{
public:
DeleteCasterEpisodeGroupRequest();
~DeleteCasterEpisodeGroupRequest();
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getProgramId()const;
void setProgramId(const std::string& programId);
private:
long ownerId_;
std::string programId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTEREPISODEGROUPREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteCasterEpisodeGroupResult.h Normal file
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_LIVE_MODEL_DELETECASTEREPISODEGROUPRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTEREPISODEGROUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterEpisodeGroupResult : public ServiceResult
{
public:
DeleteCasterEpisodeGroupResult();
explicit DeleteCasterEpisodeGroupResult(const std::string &payload);
~DeleteCasterEpisodeGroupResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTEREPISODEGROUPRESULT_H_

54
live/include/alibabacloud/live/model/DeleteCasterEpisodeRequest.h Normal file
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_LIVE_MODEL_DELETECASTEREPISODEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTEREPISODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterEpisodeRequest : public RpcServiceRequest
{
public:
DeleteCasterEpisodeRequest();
~DeleteCasterEpisodeRequest();
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getEpisodeId()const;
void setEpisodeId(const std::string& episodeId);
private:
std::string casterId_;
long ownerId_;
std::string episodeId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTEREPISODEREQUEST_H_

53
live/include/alibabacloud/live/model/DeleteCasterEpisodeResult.h Normal file
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_LIVE_MODEL_DELETECASTEREPISODERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTEREPISODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterEpisodeResult : public ServiceResult
{
public:
DeleteCasterEpisodeResult();
explicit DeleteCasterEpisodeResult(const std::string &payload);
~DeleteCasterEpisodeResult();
std::string getEpisodeId()const;
std::string getCasterId()const;
protected:
void parse(const std::string &payload);
private:
std::string episodeId_;
std::string casterId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTEREPISODERESULT_H_

54
live/include/alibabacloud/live/model/DeleteCasterLayoutRequest.h Normal file
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_LIVE_MODEL_DELETECASTERLAYOUTREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERLAYOUTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterLayoutRequest : public RpcServiceRequest
{
public:
DeleteCasterLayoutRequest();
~DeleteCasterLayoutRequest();
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getLayoutId()const;
void setLayoutId(const std::string& layoutId);
private:
std::string casterId_;
long ownerId_;
std::string layoutId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERLAYOUTREQUEST_H_

53
live/include/alibabacloud/live/model/DeleteCasterLayoutResult.h Normal file
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_LIVE_MODEL_DELETECASTERLAYOUTRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERLAYOUTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterLayoutResult : public ServiceResult
{
public:
DeleteCasterLayoutResult();
explicit DeleteCasterLayoutResult(const std::string &payload);
~DeleteCasterLayoutResult();
std::string getLayoutId()const;
std::string getCasterId()const;
protected:
void parse(const std::string &payload);
private:
std::string layoutId_;
std::string casterId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERLAYOUTRESULT_H_

51
live/include/alibabacloud/live/model/DeleteCasterProgramRequest.h Normal file
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_LIVE_MODEL_DELETECASTERPROGRAMREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERPROGRAMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterProgramRequest : public RpcServiceRequest
{
public:
DeleteCasterProgramRequest();
~DeleteCasterProgramRequest();
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string casterId_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERPROGRAMREQUEST_H_

51
live/include/alibabacloud/live/model/DeleteCasterProgramResult.h Normal file
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_LIVE_MODEL_DELETECASTERPROGRAMRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERPROGRAMRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterProgramResult : public ServiceResult
{
public:
DeleteCasterProgramResult();
explicit DeleteCasterProgramResult(const std::string &payload);
~DeleteCasterProgramResult();
std::string getCasterId()const;
protected:
void parse(const std::string &payload);
private:
std::string casterId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERPROGRAMRESULT_H_

51
live/include/alibabacloud/live/model/DeleteCasterRequest.h Normal file
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_LIVE_MODEL_DELETECASTERREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterRequest : public RpcServiceRequest
{
public:
DeleteCasterRequest();
~DeleteCasterRequest();
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string casterId_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERREQUEST_H_

51
live/include/alibabacloud/live/model/DeleteCasterResult.h Normal file
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_LIVE_MODEL_DELETECASTERRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterResult : public ServiceResult
{
public:
DeleteCasterResult();
explicit DeleteCasterResult(const std::string &payload);
~DeleteCasterResult();
std::string getCasterId()const;
protected:
void parse(const std::string &payload);
private:
std::string casterId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERRESULT_H_

57
live/include/alibabacloud/live/model/DeleteCasterSceneConfigRequest.h Normal file
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_LIVE_MODEL_DELETECASTERSCENECONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERSCENECONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterSceneConfigRequest : public RpcServiceRequest
{
public:
DeleteCasterSceneConfigRequest();
~DeleteCasterSceneConfigRequest();
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
std::string getSceneId()const;
void setSceneId(const std::string& sceneId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getType()const;
void setType(const std::string& type);
private:
std::string casterId_;
std::string sceneId_;
long ownerId_;
std::string type_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERSCENECONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteCasterSceneConfigResult.h Normal file
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_LIVE_MODEL_DELETECASTERSCENECONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERSCENECONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterSceneConfigResult : public ServiceResult
{
public:
DeleteCasterSceneConfigResult();
explicit DeleteCasterSceneConfigResult(const std::string &payload);
~DeleteCasterSceneConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERSCENECONFIGRESULT_H_

54
live/include/alibabacloud/live/model/DeleteCasterVideoResourceRequest.h Normal file
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_LIVE_MODEL_DELETECASTERVIDEORESOURCEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERVIDEORESOURCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterVideoResourceRequest : public RpcServiceRequest
{
public:
DeleteCasterVideoResourceRequest();
~DeleteCasterVideoResourceRequest();
std::string getResourceId()const;
void setResourceId(const std::string& resourceId);
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string resourceId_;
std::string casterId_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERVIDEORESOURCEREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteCasterVideoResourceResult.h Normal file
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_LIVE_MODEL_DELETECASTERVIDEORESOURCERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECASTERVIDEORESOURCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteCasterVideoResourceResult : public ServiceResult
{
public:
DeleteCasterVideoResourceResult();
explicit DeleteCasterVideoResourceResult(const std::string &payload);
~DeleteCasterVideoResourceResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECASTERVIDEORESOURCERESULT_H_

63
live/include/alibabacloud/live/model/DeleteLiveAppRecordConfigRequest.h Normal file
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_LIVE_MODEL_DELETELIVEAPPRECORDCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEAPPRECORDCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveAppRecordConfigRequest : public RpcServiceRequest
{
public:
DeleteLiveAppRecordConfigRequest();
~DeleteLiveAppRecordConfigRequest();
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string appName_;
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string streamName_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEAPPRECORDCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveAppRecordConfigResult.h Normal file
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_LIVE_MODEL_DELETELIVEAPPRECORDCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEAPPRECORDCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveAppRecordConfigResult : public ServiceResult
{
public:
DeleteLiveAppRecordConfigResult();
explicit DeleteLiveAppRecordConfigResult(const std::string &payload);
~DeleteLiveAppRecordConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEAPPRECORDCONFIGRESULT_H_

60
live/include/alibabacloud/live/model/DeleteLiveAppSnapshotConfigRequest.h Normal file
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_LIVE_MODEL_DELETELIVEAPPSNAPSHOTCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEAPPSNAPSHOTCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveAppSnapshotConfigRequest : public RpcServiceRequest
{
public:
DeleteLiveAppSnapshotConfigRequest();
~DeleteLiveAppSnapshotConfigRequest();
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string appName_;
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEAPPSNAPSHOTCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveAppSnapshotConfigResult.h Normal file
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_LIVE_MODEL_DELETELIVEAPPSNAPSHOTCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEAPPSNAPSHOTCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveAppSnapshotConfigResult : public ServiceResult
{
public:
DeleteLiveAppSnapshotConfigResult();
explicit DeleteLiveAppSnapshotConfigResult(const std::string &payload);
~DeleteLiveAppSnapshotConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEAPPSNAPSHOTCONFIGRESULT_H_

57
live/include/alibabacloud/live/model/DeleteLiveDetectNotifyConfigRequest.h Normal file
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_LIVE_MODEL_DELETELIVEDETECTNOTIFYCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEDETECTNOTIFYCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveDetectNotifyConfigRequest : public RpcServiceRequest
{
public:
DeleteLiveDetectNotifyConfigRequest();
~DeleteLiveDetectNotifyConfigRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEDETECTNOTIFYCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveDetectNotifyConfigResult.h Normal file
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_LIVE_MODEL_DELETELIVEDETECTNOTIFYCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEDETECTNOTIFYCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveDetectNotifyConfigResult : public ServiceResult
{
public:
DeleteLiveDetectNotifyConfigResult();
explicit DeleteLiveDetectNotifyConfigResult(const std::string &payload);
~DeleteLiveDetectNotifyConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEDETECTNOTIFYCONFIGRESULT_H_

60
live/include/alibabacloud/live/model/DeleteLiveMixConfigRequest.h Normal file
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_LIVE_MODEL_DELETELIVEMIXCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEMIXCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveMixConfigRequest : public RpcServiceRequest
{
public:
DeleteLiveMixConfigRequest();
~DeleteLiveMixConfigRequest();
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string appName_;
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEMIXCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveMixConfigResult.h Normal file
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_LIVE_MODEL_DELETELIVEMIXCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEMIXCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveMixConfigResult : public ServiceResult
{
public:
DeleteLiveMixConfigResult();
explicit DeleteLiveMixConfigResult(const std::string &payload);
~DeleteLiveMixConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEMIXCONFIGRESULT_H_

57
live/include/alibabacloud/live/model/DeleteLiveMixNotifyConfigRequest.h Normal file
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_LIVE_MODEL_DELETELIVEMIXNOTIFYCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEMIXNOTIFYCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveMixNotifyConfigRequest : public RpcServiceRequest
{
public:
DeleteLiveMixNotifyConfigRequest();
~DeleteLiveMixNotifyConfigRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEMIXNOTIFYCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveMixNotifyConfigResult.h Normal file
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_LIVE_MODEL_DELETELIVEMIXNOTIFYCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEMIXNOTIFYCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveMixNotifyConfigResult : public ServiceResult
{
public:
DeleteLiveMixNotifyConfigResult();
explicit DeleteLiveMixNotifyConfigResult(const std::string &payload);
~DeleteLiveMixNotifyConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEMIXNOTIFYCONFIGRESULT_H_

63
live/include/alibabacloud/live/model/DeleteLivePullStreamInfoConfigRequest.h Normal file
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_LIVE_MODEL_DELETELIVEPULLSTREAMINFOCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEPULLSTREAMINFOCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLivePullStreamInfoConfigRequest : public RpcServiceRequest
{
public:
DeleteLivePullStreamInfoConfigRequest();
~DeleteLivePullStreamInfoConfigRequest();
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string appName_;
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string streamName_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEPULLSTREAMINFOCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLivePullStreamInfoConfigResult.h Normal file
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_LIVE_MODEL_DELETELIVEPULLSTREAMINFOCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEPULLSTREAMINFOCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLivePullStreamInfoConfigResult : public ServiceResult
{
public:
DeleteLivePullStreamInfoConfigResult();
explicit DeleteLivePullStreamInfoConfigResult(const std::string &payload);
~DeleteLivePullStreamInfoConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEPULLSTREAMINFOCONFIGRESULT_H_

57
live/include/alibabacloud/live/model/DeleteLiveRecordNotifyConfigRequest.h Normal file
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_LIVE_MODEL_DELETELIVERECORDNOTIFYCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVERECORDNOTIFYCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveRecordNotifyConfigRequest : public RpcServiceRequest
{
public:
DeleteLiveRecordNotifyConfigRequest();
~DeleteLiveRecordNotifyConfigRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVERECORDNOTIFYCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveRecordNotifyConfigResult.h Normal file
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_LIVE_MODEL_DELETELIVERECORDNOTIFYCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVERECORDNOTIFYCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveRecordNotifyConfigResult : public ServiceResult
{
public:
DeleteLiveRecordNotifyConfigResult();
explicit DeleteLiveRecordNotifyConfigResult(const std::string &payload);
~DeleteLiveRecordNotifyConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVERECORDNOTIFYCONFIGRESULT_H_

63
live/include/alibabacloud/live/model/DeleteLiveRecordVodConfigRequest.h Normal file
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_LIVE_MODEL_DELETELIVERECORDVODCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVERECORDVODCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveRecordVodConfigRequest : public RpcServiceRequest
{
public:
DeleteLiveRecordVodConfigRequest();
~DeleteLiveRecordVodConfigRequest();
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string appName_;
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string streamName_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVERECORDVODCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveRecordVodConfigResult.h Normal file
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_LIVE_MODEL_DELETELIVERECORDVODCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVERECORDVODCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveRecordVodConfigResult : public ServiceResult
{
public:
DeleteLiveRecordVodConfigResult();
explicit DeleteLiveRecordVodConfigResult(const std::string &payload);
~DeleteLiveRecordVodConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVERECORDVODCONFIGRESULT_H_

60
live/include/alibabacloud/live/model/DeleteLiveSnapshotDetectPornConfigRequest.h Normal file
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_LIVE_MODEL_DELETELIVESNAPSHOTDETECTPORNCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVESNAPSHOTDETECTPORNCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveSnapshotDetectPornConfigRequest : public RpcServiceRequest
{
public:
DeleteLiveSnapshotDetectPornConfigRequest();
~DeleteLiveSnapshotDetectPornConfigRequest();
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string appName_;
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVESNAPSHOTDETECTPORNCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveSnapshotDetectPornConfigResult.h Normal file
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_LIVE_MODEL_DELETELIVESNAPSHOTDETECTPORNCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVESNAPSHOTDETECTPORNCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveSnapshotDetectPornConfigResult : public ServiceResult
{
public:
DeleteLiveSnapshotDetectPornConfigResult();
explicit DeleteLiveSnapshotDetectPornConfigResult(const std::string &payload);
~DeleteLiveSnapshotDetectPornConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVESNAPSHOTDETECTPORNCONFIGRESULT_H_

63
live/include/alibabacloud/live/model/DeleteLiveStreamTranscodeRequest.h Normal file
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_LIVE_MODEL_DELETELIVESTREAMTRANSCODEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMTRANSCODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveStreamTranscodeRequest : public RpcServiceRequest
{
public:
DeleteLiveStreamTranscodeRequest();
~DeleteLiveStreamTranscodeRequest();
std::string getApp()const;
void setApp(const std::string& app);
std::string get_Template()const;
void set_Template(const std::string& _template);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomain()const;
void setDomain(const std::string& domain);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string app_;
std::string _template_;
std::string securityToken_;
std::string domain_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMTRANSCODEREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveStreamTranscodeResult.h Normal file
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_LIVE_MODEL_DELETELIVESTREAMTRANSCODERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMTRANSCODERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveStreamTranscodeResult : public ServiceResult
{
public:
DeleteLiveStreamTranscodeResult();
explicit DeleteLiveStreamTranscodeResult(const std::string &payload);
~DeleteLiveStreamTranscodeResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMTRANSCODERESULT_H_

57
live/include/alibabacloud/live/model/DeleteLiveStreamsNotifyUrlConfigRequest.h Normal file
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_LIVE_MODEL_DELETELIVESTREAMSNOTIFYURLCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMSNOTIFYURLCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveStreamsNotifyUrlConfigRequest : public RpcServiceRequest
{
public:
DeleteLiveStreamsNotifyUrlConfigRequest();
~DeleteLiveStreamsNotifyUrlConfigRequest();
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string securityToken_;
std::string domainName_;
long ownerId_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMSNOTIFYURLCONFIGREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveStreamsNotifyUrlConfigResult.h Normal file
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_LIVE_MODEL_DELETELIVESTREAMSNOTIFYURLCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMSNOTIFYURLCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DeleteLiveStreamsNotifyUrlConfigResult : public ServiceResult
{
public:
DeleteLiveStreamsNotifyUrlConfigResult();
explicit DeleteLiveStreamsNotifyUrlConfigResult(const std::string &payload);
~DeleteLiveStreamsNotifyUrlConfigResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVESTREAMSNOTIFYURLCONFIGRESULT_H_

54
live/include/alibabacloud/live/model/DescribeCasterComponentsRequest.h Normal file
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_LIVE_MODEL_DESCRIBECASTERCOMPONENTSREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERCOMPONENTSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterComponentsRequest : public RpcServiceRequest
{
public:
DescribeCasterComponentsRequest();
~DescribeCasterComponentsRequest();
std::string getComponentId()const;
void setComponentId(const std::string& componentId);
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string componentId_;
std::string casterId_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERCOMPONENTSREQUEST_H_

96
live/include/alibabacloud/live/model/DescribeCasterComponentsResult.h Normal file
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_LIVE_MODEL_DESCRIBECASTERCOMPONENTSRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERCOMPONENTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterComponentsResult : public ServiceResult
{
public:
struct Component
{
struct ComponentLayer
{
std::vector<std::string> positionNormalizeds;
float heightNormalized;
std::string positionRefer;
float widthNormalized;
};
struct TextLayerContent
{
float borderWidthNormalized;
float sizeNormalized;
std::string color;
std::string fontName;
std::string borderColor;
std::string text;
};
struct ImageLayerContent
{
std::string materialId;
};
struct CaptionLayerContent
{
int ptsOffset;
float borderWidthNormalized;
float sizeNormalized;
std::string color;
std::string locationId;
std::string fontName;
std::string borderColor;
int wordsCount;
};
CaptionLayerContent captionLayerContent;
TextLayerContent textLayerContent;
std::string componentType;
ComponentLayer componentLayer;
std::string locationId;
std::string componentName;
std::string effect;
std::string componentId;
ImageLayerContent imageLayerContent;
};
DescribeCasterComponentsResult();
explicit DescribeCasterComponentsResult(const std::string &payload);
~DescribeCasterComponentsResult();
std::vector<Component> getComponents()const;
int getTotal()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Component> components_;
int total_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERCOMPONENTSRESULT_H_

51
live/include/alibabacloud/live/model/DescribeCasterConfigRequest.h Normal file
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_LIVE_MODEL_DESCRIBECASTERCONFIGREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERCONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterConfigRequest : public RpcServiceRequest
{
public:
DescribeCasterConfigRequest();
~DescribeCasterConfigRequest();
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string casterId_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERCONFIGREQUEST_H_

89
live/include/alibabacloud/live/model/DescribeCasterConfigResult.h Normal file
View File

@@ -0,0 +1,89 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERCONFIGRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERCONFIGRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterConfigResult : public ServiceResult
{
public:
struct TranscodeConfig
{
std::string casterTemplate;
std::vector<std::string> liveTemplateIds;
};
struct RecordConfig
{
struct RecordFormatItem
{
std::string format;
std::string sliceOssObjectPrefix;
int cycleDuration;
std::string ossObjectPrefix;
};
std::string ossEndpoint;
std::vector<RecordFormatItem> recordFormat;
std::string ossBucket;
};
DescribeCasterConfigResult();
explicit DescribeCasterConfigResult(const std::string &payload);
~DescribeCasterConfigResult();
std::string getSideOutputUrl()const;
std::string getCallbackUrl()const;
std::string getCasterName()const;
std::string getDomainName()const;
int getProgramEffect()const;
std::string getUrgentMaterialId()const;
TranscodeConfig getTranscodeConfig()const;
std::string getCasterId()const;
std::string getProgramName()const;
RecordConfig getRecordConfig()const;
float getDelay()const;
protected:
void parse(const std::string &payload);
private:
std::string sideOutputUrl_;
std::string callbackUrl_;
std::string casterName_;
std::string domainName_;
int programEffect_;
std::string urgentMaterialId_;
TranscodeConfig transcodeConfig_;
std::string casterId_;
std::string programName_;
RecordConfig recordConfig_;
float delay_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERCONFIGRESULT_H_

54
live/include/alibabacloud/live/model/DescribeCasterLayoutsRequest.h Normal file
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_LIVE_MODEL_DESCRIBECASTERLAYOUTSREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERLAYOUTSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterLayoutsRequest : public RpcServiceRequest
{
public:
DescribeCasterLayoutsRequest();
~DescribeCasterLayoutsRequest();
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getLayoutId()const;
void setLayoutId(const std::string& layoutId);
private:
std::string casterId_;
long ownerId_;
std::string layoutId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERLAYOUTSREQUEST_H_

76
live/include/alibabacloud/live/model/DescribeCasterLayoutsResult.h Normal file
View File

@@ -0,0 +1,76 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERLAYOUTSRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERLAYOUTSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterLayoutsResult : public ServiceResult
{
public:
struct Layout
{
struct VideoLayer
{
std::vector<std::string> positionNormalizeds;
std::string fillMode;
float heightNormalized;
std::string positionRefer;
int fixedDelayDuration;
float widthNormalized;
};
struct AudioLayer
{
std::string validChannel;
float volumeRate;
int fixedDelayDuration;
};
std::vector<std::string> mixList;
std::vector<Layout::AudioLayer> audioLayers;
std::vector<Layout::VideoLayer> videoLayers;
std::string layoutId;
std::vector<std::string> blendList;
};
DescribeCasterLayoutsResult();
explicit DescribeCasterLayoutsResult(const std::string &payload);
~DescribeCasterLayoutsResult();
std::vector<Layout> getLayouts()const;
int getTotal()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Layout> layouts_;
int total_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERLAYOUTSRESULT_H_

72
live/include/alibabacloud/live/model/DescribeCasterProgramRequest.h Normal file
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_LIVE_MODEL_DESCRIBECASTERPROGRAMREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERPROGRAMREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterProgramRequest : public RpcServiceRequest
{
public:
DescribeCasterProgramRequest();
~DescribeCasterProgramRequest();
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
std::string getEpisodeType()const;
void setEpisodeType(const std::string& episodeType);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getEpisodeId()const;
void setEpisodeId(const std::string& episodeId);
int getPageNum()const;
void setPageNum(int pageNum);
int getStatus()const;
void setStatus(int status);
private:
std::string casterId_;
std::string episodeType_;
int pageSize_;
std::string endTime_;
std::string startTime_;
long ownerId_;
std::string episodeId_;
int pageNum_;
int status_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERPROGRAMREQUEST_H_

71
live/include/alibabacloud/live/model/DescribeCasterProgramResult.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERPROGRAMRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERPROGRAMRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterProgramResult : public ServiceResult
{
public:
struct Episode
{
std::string switchType;
int status;
std::vector<std::string> componentIds;
std::string endTime;
std::string resourceId;
std::string episodeType;
std::string startTime;
std::string episodeId;
std::string episodeName;
};
DescribeCasterProgramResult();
explicit DescribeCasterProgramResult(const std::string &payload);
~DescribeCasterProgramResult();
int getProgramEffect()const;
int getTotal()const;
std::vector<Episode> getEpisodes()const;
std::string getCasterId()const;
std::string getProgramName()const;
protected:
void parse(const std::string &payload);
private:
int programEffect_;
int total_;
std::vector<Episode> episodes_;
std::string casterId_;
std::string programName_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERPROGRAMRESULT_H_

51
live/include/alibabacloud/live/model/DescribeCasterRtcInfoRequest.h Normal file
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_LIVE_MODEL_DESCRIBECASTERRTCINFOREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERRTCINFOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterRtcInfoRequest : public RpcServiceRequest
{
public:
DescribeCasterRtcInfoRequest();
~DescribeCasterRtcInfoRequest();
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string casterId_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERRTCINFOREQUEST_H_

53
live/include/alibabacloud/live/model/DescribeCasterRtcInfoResult.h Normal file
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_LIVE_MODEL_DESCRIBECASTERRTCINFORESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERRTCINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterRtcInfoResult : public ServiceResult
{
public:
DescribeCasterRtcInfoResult();
explicit DescribeCasterRtcInfoResult(const std::string &payload);
~DescribeCasterRtcInfoResult();
std::string getAuthToken()const;
std::string getCasterId()const;
protected:
void parse(const std::string &payload);
private:
std::string authToken_;
std::string casterId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERRTCINFORESULT_H_

54
live/include/alibabacloud/live/model/DescribeCasterScenesRequest.h Normal file
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_LIVE_MODEL_DESCRIBECASTERSCENESREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERSCENESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterScenesRequest : public RpcServiceRequest
{
public:
DescribeCasterScenesRequest();
~DescribeCasterScenesRequest();
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
std::string getSceneId()const;
void setSceneId(const std::string& sceneId);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string casterId_;
std::string sceneId_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERSCENESREQUEST_H_

70
live/include/alibabacloud/live/model/DescribeCasterScenesResult.h Normal file
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_LIVE_MODEL_DESCRIBECASTERSCENESRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERSCENESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/live/LiveExport.h>
namespace AlibabaCloud
{
namespace Live
{
namespace Model
{
class ALIBABACLOUD_LIVE_EXPORT DescribeCasterScenesResult : public ServiceResult
{
public:
struct Scene
{
struct StreamInfo
{
std::string outputStreamUrl;
std::string transcodeConfig;
std::string videoFormat;
};
std::string sceneId;
int status;
std::vector<std::string> componentIds;
std::string sceneName;
std::string layoutId;
std::vector<Scene::StreamInfo> streamInfos;
std::string streamUrl;
std::string outputType;
};
DescribeCasterScenesResult();
explicit DescribeCasterScenesResult(const std::string &payload);
~DescribeCasterScenesResult();
int getTotal()const;
std::vector<Scene> getSceneList()const;
protected:
void parse(const std::string &payload);
private:
int total_;
std::vector<Scene> sceneList_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBECASTERSCENESRESULT_H_

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