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

Generated 2016-11-01 for live.

Browse Source
This commit is contained in:
sdk-team
2021-09-16 08:28:26 +00:00
parent d9cb6a8f50
commit fcaeaecdf7
67 changed files with 2795 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
live/include/alibabacloud/live/LiveClient.h
View File

@@ -106,6 +106,8 @@
#include "model/CreateBoardResult.h"
#include "model/CreateCasterRequest.h"
#include "model/CreateCasterResult.h"
#include "model/CreateCustomTemplateRequest.h"
#include "model/CreateCustomTemplateResult.h"
#include "model/CreateLiveRealTimeLogDeliveryRequest.h"
#include "model/CreateLiveRealTimeLogDeliveryResult.h"
#include "model/CreateLiveStreamRecordIndexFilesRequest.h"
@@ -132,6 +134,8 @@
#include "model/DeleteCasterSceneConfigResult.h"
#include "model/DeleteCasterVideoResourceRequest.h"
#include "model/DeleteCasterVideoResourceResult.h"
#include "model/DeleteCustomTemplateRequest.h"
#include "model/DeleteCustomTemplateResult.h"
#include "model/DeleteHtmlResourceRequest.h"
#include "model/DeleteHtmlResourceResult.h"
#include "model/DeleteLiveASRConfigRequest.h"
@@ -152,6 +156,8 @@
#include "model/DeleteLiveDomainMappingResult.h"
#include "model/DeleteLiveDomainPlayMappingRequest.h"
#include "model/DeleteLiveDomainPlayMappingResult.h"
#include "model/DeleteLiveEdgeTransferRequest.h"
#include "model/DeleteLiveEdgeTransferResult.h"
#include "model/DeleteLiveLazyPullStreamInfoConfigRequest.h"
#include "model/DeleteLiveLazyPullStreamInfoConfigResult.h"
#include "model/DeleteLivePullStreamInfoConfigRequest.h"
@@ -288,6 +294,10 @@
#include "model/DescribeLiveDomainTranscodeDataResult.h"
#include "model/DescribeLiveDrmUsageDataRequest.h"
#include "model/DescribeLiveDrmUsageDataResult.h"
#include "model/DescribeLiveEdgeTransferRequest.h"
#include "model/DescribeLiveEdgeTransferResult.h"
#include "model/DescribeLiveIpInfoRequest.h"
#include "model/DescribeLiveIpInfoResult.h"
#include "model/DescribeLiveLazyPullStreamConfigRequest.h"
#include "model/DescribeLiveLazyPullStreamConfigResult.h"
#include "model/DescribeLivePullStreamConfigRequest.h"
@@ -328,6 +338,8 @@
#include "model/DescribeLiveStreamRecordIndexFilesResult.h"
#include "model/DescribeLiveStreamSnapshotInfoRequest.h"
#include "model/DescribeLiveStreamSnapshotInfoResult.h"
#include "model/DescribeLiveStreamStateRequest.h"
#include "model/DescribeLiveStreamStateResult.h"
#include "model/DescribeLiveStreamTranscodeInfoRequest.h"
#include "model/DescribeLiveStreamTranscodeInfoResult.h"
#include "model/DescribeLiveStreamTranscodeStreamNumRequest.h"
@@ -388,10 +400,14 @@
#include "model/EffectCasterVideoResourceResult.h"
#include "model/EnableLiveRealtimeLogDeliveryRequest.h"
#include "model/EnableLiveRealtimeLogDeliveryResult.h"
#include "model/ForbidLiveCustomStreamRequest.h"
#include "model/ForbidLiveCustomStreamResult.h"
#include "model/ForbidLiveStreamRequest.h"
#include "model/ForbidLiveStreamResult.h"
#include "model/ForbidPushStreamRequest.h"
#include "model/ForbidPushStreamResult.h"
#include "model/GetCustomTemplateRequest.h"
#include "model/GetCustomTemplateResult.h"
#include "model/GetMultiRateConfigRequest.h"
#include "model/GetMultiRateConfigResult.h"
#include "model/GetMultiRateConfigListRequest.h"
@@ -454,6 +470,8 @@
#include "model/SetLiveDomainCertificateResult.h"
#include "model/SetLiveDomainStagingConfigRequest.h"
#include "model/SetLiveDomainStagingConfigResult.h"
#include "model/SetLiveEdgeTransferRequest.h"
#include "model/SetLiveEdgeTransferResult.h"
#include "model/SetLiveLazyPullStreamInfoConfigRequest.h"
#include "model/SetLiveLazyPullStreamInfoConfigResult.h"
#include "model/SetLiveStreamDelayConfigRequest.h"
@@ -653,6 +671,9 @@ namespace AlibabaCloud
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::CreateCustomTemplateResult> CreateCustomTemplateOutcome;
typedef std::future<CreateCustomTemplateOutcome> CreateCustomTemplateOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CreateCustomTemplateRequest&, const CreateCustomTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCustomTemplateAsyncHandler;
typedef Outcome<Error, Model::CreateLiveRealTimeLogDeliveryResult> CreateLiveRealTimeLogDeliveryOutcome;
typedef std::future<CreateLiveRealTimeLogDeliveryOutcome> CreateLiveRealTimeLogDeliveryOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::CreateLiveRealTimeLogDeliveryRequest&, const CreateLiveRealTimeLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateLiveRealTimeLogDeliveryAsyncHandler;
@@ -692,6 +713,9 @@ namespace AlibabaCloud
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::DeleteCustomTemplateResult> DeleteCustomTemplateOutcome;
typedef std::future<DeleteCustomTemplateOutcome> DeleteCustomTemplateOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteCustomTemplateRequest&, const DeleteCustomTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteCustomTemplateAsyncHandler;
typedef Outcome<Error, Model::DeleteHtmlResourceResult> DeleteHtmlResourceOutcome;
typedef std::future<DeleteHtmlResourceOutcome> DeleteHtmlResourceOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteHtmlResourceRequest&, const DeleteHtmlResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteHtmlResourceAsyncHandler;
@@ -722,6 +746,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteLiveDomainPlayMappingResult> DeleteLiveDomainPlayMappingOutcome;
typedef std::future<DeleteLiveDomainPlayMappingOutcome> DeleteLiveDomainPlayMappingOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveDomainPlayMappingRequest&, const DeleteLiveDomainPlayMappingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveDomainPlayMappingAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveEdgeTransferResult> DeleteLiveEdgeTransferOutcome;
typedef std::future<DeleteLiveEdgeTransferOutcome> DeleteLiveEdgeTransferOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveEdgeTransferRequest&, const DeleteLiveEdgeTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveEdgeTransferAsyncHandler;
typedef Outcome<Error, Model::DeleteLiveLazyPullStreamInfoConfigResult> DeleteLiveLazyPullStreamInfoConfigOutcome;
typedef std::future<DeleteLiveLazyPullStreamInfoConfigOutcome> DeleteLiveLazyPullStreamInfoConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DeleteLiveLazyPullStreamInfoConfigRequest&, const DeleteLiveLazyPullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteLiveLazyPullStreamInfoConfigAsyncHandler;
@@ -926,6 +953,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeLiveDrmUsageDataResult> DescribeLiveDrmUsageDataOutcome;
typedef std::future<DescribeLiveDrmUsageDataOutcome> DescribeLiveDrmUsageDataOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveDrmUsageDataRequest&, const DescribeLiveDrmUsageDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveDrmUsageDataAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveEdgeTransferResult> DescribeLiveEdgeTransferOutcome;
typedef std::future<DescribeLiveEdgeTransferOutcome> DescribeLiveEdgeTransferOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveEdgeTransferRequest&, const DescribeLiveEdgeTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveEdgeTransferAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveIpInfoResult> DescribeLiveIpInfoOutcome;
typedef std::future<DescribeLiveIpInfoOutcome> DescribeLiveIpInfoOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveIpInfoRequest&, const DescribeLiveIpInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveIpInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeLiveLazyPullStreamConfigResult> DescribeLiveLazyPullStreamConfigOutcome;
typedef std::future<DescribeLiveLazyPullStreamConfigOutcome> DescribeLiveLazyPullStreamConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveLazyPullStreamConfigRequest&, const DescribeLiveLazyPullStreamConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveLazyPullStreamConfigAsyncHandler;
@@ -986,6 +1019,9 @@ namespace AlibabaCloud
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::DescribeLiveStreamStateResult> DescribeLiveStreamStateOutcome;
typedef std::future<DescribeLiveStreamStateOutcome> DescribeLiveStreamStateOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::DescribeLiveStreamStateRequest&, const DescribeLiveStreamStateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLiveStreamStateAsyncHandler;
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;
@@ -1076,12 +1112,18 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::EnableLiveRealtimeLogDeliveryResult> EnableLiveRealtimeLogDeliveryOutcome;
typedef std::future<EnableLiveRealtimeLogDeliveryOutcome> EnableLiveRealtimeLogDeliveryOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::EnableLiveRealtimeLogDeliveryRequest&, const EnableLiveRealtimeLogDeliveryOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableLiveRealtimeLogDeliveryAsyncHandler;
typedef Outcome<Error, Model::ForbidLiveCustomStreamResult> ForbidLiveCustomStreamOutcome;
typedef std::future<ForbidLiveCustomStreamOutcome> ForbidLiveCustomStreamOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ForbidLiveCustomStreamRequest&, const ForbidLiveCustomStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ForbidLiveCustomStreamAsyncHandler;
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::ForbidPushStreamResult> ForbidPushStreamOutcome;
typedef std::future<ForbidPushStreamOutcome> ForbidPushStreamOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::ForbidPushStreamRequest&, const ForbidPushStreamOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ForbidPushStreamAsyncHandler;
typedef Outcome<Error, Model::GetCustomTemplateResult> GetCustomTemplateOutcome;
typedef std::future<GetCustomTemplateOutcome> GetCustomTemplateOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::GetCustomTemplateRequest&, const GetCustomTemplateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCustomTemplateAsyncHandler;
typedef Outcome<Error, Model::GetMultiRateConfigResult> GetMultiRateConfigOutcome;
typedef std::future<GetMultiRateConfigOutcome> GetMultiRateConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::GetMultiRateConfigRequest&, const GetMultiRateConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetMultiRateConfigAsyncHandler;
@@ -1175,6 +1217,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::SetLiveDomainStagingConfigResult> SetLiveDomainStagingConfigOutcome;
typedef std::future<SetLiveDomainStagingConfigOutcome> SetLiveDomainStagingConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::SetLiveDomainStagingConfigRequest&, const SetLiveDomainStagingConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLiveDomainStagingConfigAsyncHandler;
typedef Outcome<Error, Model::SetLiveEdgeTransferResult> SetLiveEdgeTransferOutcome;
typedef std::future<SetLiveEdgeTransferOutcome> SetLiveEdgeTransferOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::SetLiveEdgeTransferRequest&, const SetLiveEdgeTransferOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLiveEdgeTransferAsyncHandler;
typedef Outcome<Error, Model::SetLiveLazyPullStreamInfoConfigResult> SetLiveLazyPullStreamInfoConfigOutcome;
typedef std::future<SetLiveLazyPullStreamInfoConfigOutcome> SetLiveLazyPullStreamInfoConfigOutcomeCallable;
typedef std::function<void(const LiveClient*, const Model::SetLiveLazyPullStreamInfoConfigRequest&, const SetLiveLazyPullStreamInfoConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetLiveLazyPullStreamInfoConfigAsyncHandler;
@@ -1402,6 +1447,9 @@ namespace AlibabaCloud
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;
CreateCustomTemplateOutcome createCustomTemplate(const Model::CreateCustomTemplateRequest &request)const;
void createCustomTemplateAsync(const Model::CreateCustomTemplateRequest& request, const CreateCustomTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateCustomTemplateOutcomeCallable createCustomTemplateCallable(const Model::CreateCustomTemplateRequest& request) const;
CreateLiveRealTimeLogDeliveryOutcome createLiveRealTimeLogDelivery(const Model::CreateLiveRealTimeLogDeliveryRequest &request)const;
void createLiveRealTimeLogDeliveryAsync(const Model::CreateLiveRealTimeLogDeliveryRequest& request, const CreateLiveRealTimeLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateLiveRealTimeLogDeliveryOutcomeCallable createLiveRealTimeLogDeliveryCallable(const Model::CreateLiveRealTimeLogDeliveryRequest& request) const;
@@ -1441,6 +1489,9 @@ namespace AlibabaCloud
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;
DeleteCustomTemplateOutcome deleteCustomTemplate(const Model::DeleteCustomTemplateRequest &request)const;
void deleteCustomTemplateAsync(const Model::DeleteCustomTemplateRequest& request, const DeleteCustomTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteCustomTemplateOutcomeCallable deleteCustomTemplateCallable(const Model::DeleteCustomTemplateRequest& request) const;
DeleteHtmlResourceOutcome deleteHtmlResource(const Model::DeleteHtmlResourceRequest &request)const;
void deleteHtmlResourceAsync(const Model::DeleteHtmlResourceRequest& request, const DeleteHtmlResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteHtmlResourceOutcomeCallable deleteHtmlResourceCallable(const Model::DeleteHtmlResourceRequest& request) const;
@@ -1471,6 +1522,9 @@ namespace AlibabaCloud
DeleteLiveDomainPlayMappingOutcome deleteLiveDomainPlayMapping(const Model::DeleteLiveDomainPlayMappingRequest &request)const;
void deleteLiveDomainPlayMappingAsync(const Model::DeleteLiveDomainPlayMappingRequest& request, const DeleteLiveDomainPlayMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveDomainPlayMappingOutcomeCallable deleteLiveDomainPlayMappingCallable(const Model::DeleteLiveDomainPlayMappingRequest& request) const;
DeleteLiveEdgeTransferOutcome deleteLiveEdgeTransfer(const Model::DeleteLiveEdgeTransferRequest &request)const;
void deleteLiveEdgeTransferAsync(const Model::DeleteLiveEdgeTransferRequest& request, const DeleteLiveEdgeTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveEdgeTransferOutcomeCallable deleteLiveEdgeTransferCallable(const Model::DeleteLiveEdgeTransferRequest& request) const;
DeleteLiveLazyPullStreamInfoConfigOutcome deleteLiveLazyPullStreamInfoConfig(const Model::DeleteLiveLazyPullStreamInfoConfigRequest &request)const;
void deleteLiveLazyPullStreamInfoConfigAsync(const Model::DeleteLiveLazyPullStreamInfoConfigRequest& request, const DeleteLiveLazyPullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteLiveLazyPullStreamInfoConfigOutcomeCallable deleteLiveLazyPullStreamInfoConfigCallable(const Model::DeleteLiveLazyPullStreamInfoConfigRequest& request) const;
@@ -1675,6 +1729,12 @@ namespace AlibabaCloud
DescribeLiveDrmUsageDataOutcome describeLiveDrmUsageData(const Model::DescribeLiveDrmUsageDataRequest &request)const;
void describeLiveDrmUsageDataAsync(const Model::DescribeLiveDrmUsageDataRequest& request, const DescribeLiveDrmUsageDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveDrmUsageDataOutcomeCallable describeLiveDrmUsageDataCallable(const Model::DescribeLiveDrmUsageDataRequest& request) const;
DescribeLiveEdgeTransferOutcome describeLiveEdgeTransfer(const Model::DescribeLiveEdgeTransferRequest &request)const;
void describeLiveEdgeTransferAsync(const Model::DescribeLiveEdgeTransferRequest& request, const DescribeLiveEdgeTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveEdgeTransferOutcomeCallable describeLiveEdgeTransferCallable(const Model::DescribeLiveEdgeTransferRequest& request) const;
DescribeLiveIpInfoOutcome describeLiveIpInfo(const Model::DescribeLiveIpInfoRequest &request)const;
void describeLiveIpInfoAsync(const Model::DescribeLiveIpInfoRequest& request, const DescribeLiveIpInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveIpInfoOutcomeCallable describeLiveIpInfoCallable(const Model::DescribeLiveIpInfoRequest& request) const;
DescribeLiveLazyPullStreamConfigOutcome describeLiveLazyPullStreamConfig(const Model::DescribeLiveLazyPullStreamConfigRequest &request)const;
void describeLiveLazyPullStreamConfigAsync(const Model::DescribeLiveLazyPullStreamConfigRequest& request, const DescribeLiveLazyPullStreamConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveLazyPullStreamConfigOutcomeCallable describeLiveLazyPullStreamConfigCallable(const Model::DescribeLiveLazyPullStreamConfigRequest& request) const;
@@ -1735,6 +1795,9 @@ namespace AlibabaCloud
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;
DescribeLiveStreamStateOutcome describeLiveStreamState(const Model::DescribeLiveStreamStateRequest &request)const;
void describeLiveStreamStateAsync(const Model::DescribeLiveStreamStateRequest& request, const DescribeLiveStreamStateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLiveStreamStateOutcomeCallable describeLiveStreamStateCallable(const Model::DescribeLiveStreamStateRequest& 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;
@@ -1825,12 +1888,18 @@ namespace AlibabaCloud
EnableLiveRealtimeLogDeliveryOutcome enableLiveRealtimeLogDelivery(const Model::EnableLiveRealtimeLogDeliveryRequest &request)const;
void enableLiveRealtimeLogDeliveryAsync(const Model::EnableLiveRealtimeLogDeliveryRequest& request, const EnableLiveRealtimeLogDeliveryAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableLiveRealtimeLogDeliveryOutcomeCallable enableLiveRealtimeLogDeliveryCallable(const Model::EnableLiveRealtimeLogDeliveryRequest& request) const;
ForbidLiveCustomStreamOutcome forbidLiveCustomStream(const Model::ForbidLiveCustomStreamRequest &request)const;
void forbidLiveCustomStreamAsync(const Model::ForbidLiveCustomStreamRequest& request, const ForbidLiveCustomStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ForbidLiveCustomStreamOutcomeCallable forbidLiveCustomStreamCallable(const Model::ForbidLiveCustomStreamRequest& 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;
ForbidPushStreamOutcome forbidPushStream(const Model::ForbidPushStreamRequest &request)const;
void forbidPushStreamAsync(const Model::ForbidPushStreamRequest& request, const ForbidPushStreamAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ForbidPushStreamOutcomeCallable forbidPushStreamCallable(const Model::ForbidPushStreamRequest& request) const;
GetCustomTemplateOutcome getCustomTemplate(const Model::GetCustomTemplateRequest &request)const;
void getCustomTemplateAsync(const Model::GetCustomTemplateRequest& request, const GetCustomTemplateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetCustomTemplateOutcomeCallable getCustomTemplateCallable(const Model::GetCustomTemplateRequest& request) const;
GetMultiRateConfigOutcome getMultiRateConfig(const Model::GetMultiRateConfigRequest &request)const;
void getMultiRateConfigAsync(const Model::GetMultiRateConfigRequest& request, const GetMultiRateConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetMultiRateConfigOutcomeCallable getMultiRateConfigCallable(const Model::GetMultiRateConfigRequest& request) const;
@@ -1924,6 +1993,9 @@ namespace AlibabaCloud
SetLiveDomainStagingConfigOutcome setLiveDomainStagingConfig(const Model::SetLiveDomainStagingConfigRequest &request)const;
void setLiveDomainStagingConfigAsync(const Model::SetLiveDomainStagingConfigRequest& request, const SetLiveDomainStagingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLiveDomainStagingConfigOutcomeCallable setLiveDomainStagingConfigCallable(const Model::SetLiveDomainStagingConfigRequest& request) const;
SetLiveEdgeTransferOutcome setLiveEdgeTransfer(const Model::SetLiveEdgeTransferRequest &request)const;
void setLiveEdgeTransferAsync(const Model::SetLiveEdgeTransferRequest& request, const SetLiveEdgeTransferAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLiveEdgeTransferOutcomeCallable setLiveEdgeTransferCallable(const Model::SetLiveEdgeTransferRequest& request) const;
SetLiveLazyPullStreamInfoConfigOutcome setLiveLazyPullStreamInfoConfig(const Model::SetLiveLazyPullStreamInfoConfigRequest &request)const;
void setLiveLazyPullStreamInfoConfigAsync(const Model::SetLiveLazyPullStreamInfoConfigRequest& request, const SetLiveLazyPullStreamInfoConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SetLiveLazyPullStreamInfoConfigOutcomeCallable setLiveLazyPullStreamInfoConfigCallable(const Model::SetLiveLazyPullStreamInfoConfigRequest& request) const;

6
live/include/alibabacloud/live/model/AddCasterVideoResourceRequest.h
View File

@@ -35,6 +35,8 @@ namespace AlibabaCloud
AddCasterVideoResourceRequest();
~AddCasterVideoResourceRequest();
int getInputType()const;
void setInputType(int inputType);
int getEndOffset()const;
void setEndOffset(int endOffset);
std::string getMaterialId()const;
@@ -47,6 +49,8 @@ namespace AlibabaCloud
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
int getStreamMonitor()const;
void setStreamMonitor(int streamMonitor);
int getBeginOffset()const;
void setBeginOffset(int beginOffset);
std::string getLiveStreamUrl()const;
@@ -61,12 +65,14 @@ namespace AlibabaCloud
void setRepeatNum(int repeatNum);
private:
int inputType_;
int endOffset_;
std::string materialId_;
std::string vodUrl_;
std::string streamId_;
std::string casterId_;
long ownerId_;
int streamMonitor_;
int beginOffset_;
std::string liveStreamUrl_;
std::string locationId_;

15
live/include/alibabacloud/live/model/AddLiveAppRecordConfigRequest.h
View File

@@ -31,9 +31,18 @@ namespace AlibabaCloud
class ALIBABACLOUD_LIVE_EXPORT AddLiveAppRecordConfigRequest : public RpcServiceRequest
{
public:
struct TranscodeRecordFormat
{
std::string sliceOssObjectPrefix;
int sliceDuration;
std::string format;
std::string ossObjectPrefix;
int cycleDuration;
};
struct RecordFormat
{
std::string sliceOssObjectPrefix;
int sliceDuration;
std::string format;
std::string ossObjectPrefix;
int cycleDuration;
@@ -45,12 +54,16 @@ namespace AlibabaCloud
std::string getOssEndpoint()const;
void setOssEndpoint(const std::string& ossEndpoint);
std::vector<std::string> getTranscodeTemplates()const;
void setTranscodeTemplates(const std::vector<std::string>& transcodeTemplates);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::vector<TranscodeRecordFormat> getTranscodeRecordFormat()const;
void setTranscodeRecordFormat(const std::vector<TranscodeRecordFormat>& transcodeRecordFormat);
int getOnDemand()const;
void setOnDemand(int onDemand);
std::string getStreamName()const;
@@ -68,9 +81,11 @@ namespace AlibabaCloud
private:
std::string ossEndpoint_;
std::vector<std::string> transcodeTemplates_;
std::string startTime_;
std::string appName_;
std::string securityToken_;
std::vector<TranscodeRecordFormat> transcodeRecordFormat_;
int onDemand_;
std::string streamName_;
std::string ossBucket_;

54
live/include/alibabacloud/live/model/CreateCustomTemplateRequest.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_CREATECUSTOMTEMPLATEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_CREATECUSTOMTEMPLATEREQUEST_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 CreateCustomTemplateRequest : public RpcServiceRequest
{
public:
CreateCustomTemplateRequest();
~CreateCustomTemplateRequest();
std::string get_Template()const;
void set_Template(const std::string& _template);
std::string getCustomTemplate()const;
void setCustomTemplate(const std::string& customTemplate);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string _template_;
std::string customTemplate_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_CREATECUSTOMTEMPLATEREQUEST_H_

49
live/include/alibabacloud/live/model/CreateCustomTemplateResult.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_CREATECUSTOMTEMPLATERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_CREATECUSTOMTEMPLATERESULT_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 CreateCustomTemplateResult : public ServiceResult
{
public:
CreateCustomTemplateResult();
explicit CreateCustomTemplateResult(const std::string &payload);
~CreateCustomTemplateResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_CREATECUSTOMTEMPLATERESULT_H_

51
live/include/alibabacloud/live/model/DeleteCustomTemplateRequest.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_DELETECUSTOMTEMPLATEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECUSTOMTEMPLATEREQUEST_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 DeleteCustomTemplateRequest : public RpcServiceRequest
{
public:
DeleteCustomTemplateRequest();
~DeleteCustomTemplateRequest();
std::string get_Template()const;
void set_Template(const std::string& _template);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string _template_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECUSTOMTEMPLATEREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteCustomTemplateResult.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_DELETECUSTOMTEMPLATERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETECUSTOMTEMPLATERESULT_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 DeleteCustomTemplateResult : public ServiceResult
{
public:
DeleteCustomTemplateResult();
explicit DeleteCustomTemplateResult(const std::string &payload);
~DeleteCustomTemplateResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETECUSTOMTEMPLATERESULT_H_

51
live/include/alibabacloud/live/model/DeleteLiveEdgeTransferRequest.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_DELETELIVEEDGETRANSFERREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEEDGETRANSFERREQUEST_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 DeleteLiveEdgeTransferRequest : public RpcServiceRequest
{
public:
DeleteLiveEdgeTransferRequest();
~DeleteLiveEdgeTransferRequest();
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEEDGETRANSFERREQUEST_H_

49
live/include/alibabacloud/live/model/DeleteLiveEdgeTransferResult.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_DELETELIVEEDGETRANSFERRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DELETELIVEEDGETRANSFERRESULT_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 DeleteLiveEdgeTransferResult : public ServiceResult
{
public:
DeleteLiveEdgeTransferResult();
explicit DeleteLiveEdgeTransferResult(const std::string &payload);
~DeleteLiveEdgeTransferResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DELETELIVEEDGETRANSFERRESULT_H_

3
live/include/alibabacloud/live/model/DescribeCasterChannelsResult.h
View File

@@ -34,7 +34,10 @@ namespace AlibabaCloud
public:
struct Channel
{
std::string faceBeauty;
int inputType;
std::string resourceId;
std::string rtsUrl;
std::string channelId;
std::string streamUrl;
std::string rtmpUrl;

1
live/include/alibabacloud/live/model/DescribeCasterScenesResult.h
View File

@@ -46,6 +46,7 @@ namespace AlibabaCloud
std::string sceneName;
std::string layoutId;
std::vector<Scene::StreamInfo> streamInfos;
std::string rtsUrl;
std::string streamUrl;
std::string outputType;
};

1
live/include/alibabacloud/live/model/DescribeCasterVideoResourcesResult.h
View File

@@ -37,6 +37,7 @@ namespace AlibabaCloud
int endOffset;
int beginOffset;
std::string materialId;
std::string flvUrl;
std::string resourceId;
std::string resourceName;
std::string locationId;

2
live/include/alibabacloud/live/model/DescribeLiveDomainRecordUsageDataResult.h
View File

@@ -35,7 +35,7 @@ namespace AlibabaCloud
struct DataModule
{
std::string type;
long size;
long duration;
long count;
std::string domain;
std::string timeStamp;

51
live/include/alibabacloud/live/model/DescribeLiveEdgeTransferRequest.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_DESCRIBELIVEEDGETRANSFERREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEEDGETRANSFERREQUEST_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 DescribeLiveEdgeTransferRequest : public RpcServiceRequest
{
public:
DescribeLiveEdgeTransferRequest();
~DescribeLiveEdgeTransferRequest();
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEEDGETRANSFERREQUEST_H_

61
live/include/alibabacloud/live/model/DescribeLiveEdgeTransferResult.h Normal file
View File

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

54
live/include/alibabacloud/live/model/DescribeLiveIpInfoRequest.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_DESCRIBELIVEIPINFOREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEIPINFOREQUEST_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 DescribeLiveIpInfoRequest : public RpcServiceRequest
{
public:
DescribeLiveIpInfoRequest();
~DescribeLiveIpInfoRequest();
std::string getMethod()const;
void setMethod(const std::string& method);
std::string getIP()const;
void setIP(const std::string& iP);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string method_;
std::string iP_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEIPINFOREQUEST_H_

57
live/include/alibabacloud/live/model/DescribeLiveIpInfoResult.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_DESCRIBELIVEIPINFORESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEIPINFORESULT_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 DescribeLiveIpInfoResult : public ServiceResult
{
public:
DescribeLiveIpInfoResult();
explicit DescribeLiveIpInfoResult(const std::string &payload);
~DescribeLiveIpInfoResult();
std::string getISP()const;
std::string getRegion()const;
std::string getIspEname()const;
std::string getRegionEname()const;
protected:
void parse(const std::string &payload);
private:
std::string iSP_;
std::string region_;
std::string ispEname_;
std::string regionEname_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVEIPINFORESULT_H_

11
live/include/alibabacloud/live/model/DescribeLiveRecordConfigResult.h
View File

@@ -39,6 +39,15 @@ namespace AlibabaCloud
std::string format;
std::string sliceOssObjectPrefix;
int cycleDuration;
int sliceDuration;
std::string ossObjectPrefix;
};
struct RecordFormat
{
std::string format;
std::string sliceOssObjectPrefix;
int cycleDuration;
int sliceDuration;
std::string ossObjectPrefix;
};
std::string streamName;
@@ -46,9 +55,11 @@ namespace AlibabaCloud
std::string endTime;
std::string domainName;
std::string createTime;
std::vector<std::string> transcodeTemplates;
std::string ossBucket;
std::string startTime;
std::vector<LiveAppRecord::RecordFormat> recordFormatList;
std::vector<LiveAppRecord::RecordFormat> transcodeRecordFormatList;
int onDemond;
std::string appName;
};

57
live/include/alibabacloud/live/model/DescribeLiveStreamStateRequest.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_DESCRIBELIVESTREAMSTATEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMSTATEREQUEST_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 DescribeLiveStreamStateRequest : public RpcServiceRequest
{
public:
DescribeLiveStreamStateRequest();
~DescribeLiveStreamStateRequest();
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string appName_;
std::string streamName_;
std::string domainName_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMSTATEREQUEST_H_

53
live/include/alibabacloud/live/model/DescribeLiveStreamStateResult.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_DESCRIBELIVESTREAMSTATERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMSTATERESULT_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 DescribeLiveStreamStateResult : public ServiceResult
{
public:
DescribeLiveStreamStateResult();
explicit DescribeLiveStreamStateResult(const std::string &payload);
~DescribeLiveStreamStateResult();
std::string getStreamState()const;
std::string getType()const;
protected:
void parse(const std::string &payload);
private:
std::string streamState_;
std::string type_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_DESCRIBELIVESTREAMSTATERESULT_H_

2
live/include/alibabacloud/live/model/DescribeLiveStreamsNotifyUrlConfigResult.h
View File

@@ -36,7 +36,9 @@ namespace AlibabaCloud
{
std::string domainName;
std::string notifyUrl;
std::string notifyReqAuth;
std::string authKey;
std::string notifyAuthKey;
std::string authType;
};

84
live/include/alibabacloud/live/model/ForbidLiveCustomStreamRequest.h Normal file
View File

@@ -0,0 +1,84 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR 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_FORBIDLIVECUSTOMSTREAMREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_FORBIDLIVECUSTOMSTREAMREQUEST_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 ForbidLiveCustomStreamRequest : public RpcServiceRequest
{
public:
ForbidLiveCustomStreamRequest();
~ForbidLiveCustomStreamRequest();
std::string getStyp()const;
void setStyp(const std::string& styp);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getControlStreamAction()const;
void setControlStreamAction(const std::string& controlStreamAction);
std::string getNeedwm()const;
void setNeedwm(const std::string& needwm);
std::string getResumeTime()const;
void setResumeTime(const std::string& resumeTime);
std::string getLiveStreamType()const;
void setLiveStreamType(const std::string& liveStreamType);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getSphd()const;
void setSphd(const std::string& sphd);
std::string getOneshot()const;
void setOneshot(const std::string& oneshot);
std::string getAppid()const;
void setAppid(const std::string& appid);
std::string getRatio()const;
void setRatio(const std::string& ratio);
private:
std::string styp_;
std::string appName_;
std::string streamName_;
std::string controlStreamAction_;
std::string needwm_;
std::string resumeTime_;
std::string liveStreamType_;
std::string domainName_;
long ownerId_;
std::string sphd_;
std::string oneshot_;
std::string appid_;
std::string ratio_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_FORBIDLIVECUSTOMSTREAMREQUEST_H_

49
live/include/alibabacloud/live/model/ForbidLiveCustomStreamResult.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_FORBIDLIVECUSTOMSTREAMRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_FORBIDLIVECUSTOMSTREAMRESULT_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 ForbidLiveCustomStreamResult : public ServiceResult
{
public:
ForbidLiveCustomStreamResult();
explicit ForbidLiveCustomStreamResult(const std::string &payload);
~ForbidLiveCustomStreamResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_FORBIDLIVECUSTOMSTREAMRESULT_H_

51
live/include/alibabacloud/live/model/GetCustomTemplateRequest.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_GETCUSTOMTEMPLATEREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_GETCUSTOMTEMPLATEREQUEST_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 GetCustomTemplateRequest : public RpcServiceRequest
{
public:
GetCustomTemplateRequest();
~GetCustomTemplateRequest();
std::string get_Template()const;
void set_Template(const std::string& _template);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string _template_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_GETCUSTOMTEMPLATEREQUEST_H_

53
live/include/alibabacloud/live/model/GetCustomTemplateResult.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_GETCUSTOMTEMPLATERESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_GETCUSTOMTEMPLATERESULT_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 GetCustomTemplateResult : public ServiceResult
{
public:
GetCustomTemplateResult();
explicit GetCustomTemplateResult(const std::string &payload);
~GetCustomTemplateResult();
std::string get_Template()const;
std::string getCustomTemplate()const;
protected:
void parse(const std::string &payload);
private:
std::string _template_;
std::string customTemplate_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_GETCUSTOMTEMPLATERESULT_H_

3
live/include/alibabacloud/live/model/SetCasterChannelRequest.h
View File

@@ -35,6 +35,8 @@ namespace AlibabaCloud
SetCasterChannelRequest();
~SetCasterChannelRequest();
std::string getFaceBeauty()const;
void setFaceBeauty(const std::string& faceBeauty);
int getSeekOffset()const;
void setSeekOffset(int seekOffset);
int getPlayStatus()const;
@@ -51,6 +53,7 @@ namespace AlibabaCloud
void setChannelId(const std::string& channelId);
private:
std::string faceBeauty_;
int seekOffset_;
int playStatus_;
std::string resourceId_;

1
live/include/alibabacloud/live/model/SetCasterSyncGroupRequest.h
View File

@@ -37,6 +37,7 @@ namespace AlibabaCloud
long syncDelayThreshold;
std::string hostResourceId;
std::vector<std::string> resourceIds;
std::vector<int> syncOffsets;
};
public:

66
live/include/alibabacloud/live/model/SetLiveEdgeTransferRequest.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_SETLIVEEDGETRANSFERREQUEST_H_
#define ALIBABACLOUD_LIVE_MODEL_SETLIVEEDGETRANSFERREQUEST_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 SetLiveEdgeTransferRequest : public RpcServiceRequest
{
public:
SetLiveEdgeTransferRequest();
~SetLiveEdgeTransferRequest();
std::string getTransferArgs()const;
void setTransferArgs(const std::string& transferArgs);
std::string getAppName()const;
void setAppName(const std::string& appName);
std::string getStreamName()const;
void setStreamName(const std::string& streamName);
std::string getTargetDomainList()const;
void setTargetDomainList(const std::string& targetDomainList);
std::string getDomainName()const;
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getHttpDns()const;
void setHttpDns(const std::string& httpDns);
private:
std::string transferArgs_;
std::string appName_;
std::string streamName_;
std::string targetDomainList_;
std::string domainName_;
long ownerId_;
std::string httpDns_;
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_SETLIVEEDGETRANSFERREQUEST_H_

49
live/include/alibabacloud/live/model/SetLiveEdgeTransferResult.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_SETLIVEEDGETRANSFERRESULT_H_
#define ALIBABACLOUD_LIVE_MODEL_SETLIVEEDGETRANSFERRESULT_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 SetLiveEdgeTransferResult : public ServiceResult
{
public:
SetLiveEdgeTransferResult();
explicit SetLiveEdgeTransferResult(const std::string &payload);
~SetLiveEdgeTransferResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_LIVE_MODEL_SETLIVEEDGETRANSFERRESULT_H_

6
live/include/alibabacloud/live/model/SetLiveStreamsNotifyUrlConfigRequest.h
View File

@@ -39,6 +39,8 @@ namespace AlibabaCloud
void setAuthKey(const std::string& authKey);
std::string getAuthType()const;
void setAuthType(const std::string& authType);
std::string getNotifyReqAuth()const;
void setNotifyReqAuth(const std::string& notifyReqAuth);
std::string getNotifyUrl()const;
void setNotifyUrl(const std::string& notifyUrl);
std::string getNotifyType()const;
@@ -47,14 +49,18 @@ namespace AlibabaCloud
void setDomainName(const std::string& domainName);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getNotifyAuthKey()const;
void setNotifyAuthKey(const std::string& notifyAuthKey);
private:
std::string authKey_;
std::string authType_;
std::string notifyReqAuth_;
std::string notifyUrl_;
std::string notifyType_;
std::string domainName_;
long ownerId_;
std::string notifyAuthKey_;
};
}

3
live/include/alibabacloud/live/model/StartCasterRequest.h
View File

@@ -35,12 +35,15 @@ namespace AlibabaCloud
StartCasterRequest();
~StartCasterRequest();
int getPlayerType()const;
void setPlayerType(int playerType);
std::string getCasterId()const;
void setCasterId(const std::string& casterId);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
int playerType_;
std::string casterId_;
long ownerId_;

2
live/include/alibabacloud/live/model/StartCasterResult.h
View File

@@ -35,6 +35,7 @@ namespace AlibabaCloud
struct SceneInfo
{
std::string sceneId;
std::string rtsUrl;
std::string streamUrl;
};
struct SceneInfo1
@@ -47,6 +48,7 @@ namespace AlibabaCloud
};
std::string sceneId;
std::vector<SceneInfo1::StreamInfo> streamInfos;
std::string rtsUrl;
std::string streamUrl;
};