SCDN SDK Auto Released By xiaoyao,Version：1.34.5

Signed-off-by: yixiong.jxy <yixiong.jxy@alibaba-inc.com>

CHANGELOG

@@ -1,3 +1,6 @@
+2018-12-03 Version: 1.34.5
+1, Sync CDN API.
+
 2018-12-03 Version: 1.34.4
 1, Sync CDN API.
 

VERSION

@@ -1 +1 @@
-1.34.4
+1.34.5

scdn/CMakeLists.txt

@@ -23,26 +23,40 @@ set(scdn_public_header
 set(scdn_public_header_model 
 	include/alibabacloud/scdn/model/DescribeScdnRefreshQuotaRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnRefreshQuotaResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeByteHitRateDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeByteHitRateDataResult.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainTrafficDataRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainTrafficDataResult.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainDetailRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainDetailResult.h
+	include/alibabacloud/scdn/model/SetDomainServerCertificateRequest.h
+	include/alibabacloud/scdn/model/SetDomainServerCertificateResult.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainOriginBpsDataRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainOriginBpsDataResult.h
 	include/alibabacloud/scdn/model/DescribeScdnCertificateListRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnCertificateListResult.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainQpsDataRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainQpsDataResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainTopReferVisitRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainTopReferVisitResult.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainUvDataRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainUvDataResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRegionDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRegionDataResult.h
 	include/alibabacloud/scdn/model/DescribeScdnIpInfoRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnIpInfoResult.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainConfigsRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainConfigsResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeBpsDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeBpsDataResult.h
 	include/alibabacloud/scdn/model/SetScdnDomainCertificateRequest.h
 	include/alibabacloud/scdn/model/SetScdnDomainCertificateResult.h
 	include/alibabacloud/scdn/model/BatchDeleteScdnDomainConfigsRequest.h
 	include/alibabacloud/scdn/model/BatchDeleteScdnDomainConfigsResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcTrafficDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcTrafficDataResult.h
+	include/alibabacloud/scdn/model/DescribeScdnTopDomainsByFlowRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnTopDomainsByFlowResult.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainBpsDataRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainBpsDataResult.h
 	include/alibabacloud/scdn/model/PreloadScdnObjectCachesRequest.h
@@ -75,43 +89,73 @@ set(scdn_public_header_model
 	include/alibabacloud/scdn/model/DescribeScdnDomainHttpCodeDataResult.h
 	include/alibabacloud/scdn/model/RefreshScdnObjectCachesRequest.h
 	include/alibabacloud/scdn/model/RefreshScdnObjectCachesResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeTrafficDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeTrafficDataResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeQpsDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeQpsDataResult.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainCertificateInfoRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainCertificateInfoResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeHttpCodeDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeHttpCodeDataResult.h
 	include/alibabacloud/scdn/model/CheckScdnServiceRequest.h
 	include/alibabacloud/scdn/model/CheckScdnServiceResult.h
+	include/alibabacloud/scdn/model/BatchUpdateScdnDomainRequest.h
+	include/alibabacloud/scdn/model/BatchUpdateScdnDomainResult.h
 	include/alibabacloud/scdn/model/UpdateScdnDomainRequest.h
 	include/alibabacloud/scdn/model/UpdateScdnDomainResult.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainOriginTrafficDataRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainOriginTrafficDataResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeReqHitRateDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeReqHitRateDataResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcBpsDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcBpsDataResult.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainIspDataRequest.h
 	include/alibabacloud/scdn/model/DescribeScdnDomainIspDataResult.h
 	include/alibabacloud/scdn/model/DescribeScdnRefreshTasksRequest.h
-	include/alibabacloud/scdn/model/DescribeScdnRefreshTasksResult.h )
+	include/alibabacloud/scdn/model/DescribeScdnRefreshTasksResult.h
+	include/alibabacloud/scdn/model/OpenScdnServiceRequest.h
+	include/alibabacloud/scdn/model/OpenScdnServiceResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainTopUrlVisitRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainTopUrlVisitResult.h )
 
 set(scdn_src 
 	src/ScdnClient.cc
 	src/model/DescribeScdnRefreshQuotaRequest.cc
 	src/model/DescribeScdnRefreshQuotaResult.cc
+	src/model/DescribeScdnDomainRealTimeByteHitRateDataRequest.cc
+	src/model/DescribeScdnDomainRealTimeByteHitRateDataResult.cc
 	src/model/DescribeScdnDomainTrafficDataRequest.cc
 	src/model/DescribeScdnDomainTrafficDataResult.cc
 	src/model/DescribeScdnDomainDetailRequest.cc
 	src/model/DescribeScdnDomainDetailResult.cc
+	src/model/SetDomainServerCertificateRequest.cc
+	src/model/SetDomainServerCertificateResult.cc
 	src/model/DescribeScdnDomainOriginBpsDataRequest.cc
 	src/model/DescribeScdnDomainOriginBpsDataResult.cc
 	src/model/DescribeScdnCertificateListRequest.cc
 	src/model/DescribeScdnCertificateListResult.cc
 	src/model/DescribeScdnDomainQpsDataRequest.cc
 	src/model/DescribeScdnDomainQpsDataResult.cc
+	src/model/DescribeScdnDomainTopReferVisitRequest.cc
+	src/model/DescribeScdnDomainTopReferVisitResult.cc
 	src/model/DescribeScdnDomainUvDataRequest.cc
 	src/model/DescribeScdnDomainUvDataResult.cc
+	src/model/DescribeScdnDomainRegionDataRequest.cc
+	src/model/DescribeScdnDomainRegionDataResult.cc
 	src/model/DescribeScdnIpInfoRequest.cc
 	src/model/DescribeScdnIpInfoResult.cc
 	src/model/DescribeScdnDomainConfigsRequest.cc
 	src/model/DescribeScdnDomainConfigsResult.cc
+	src/model/DescribeScdnDomainRealTimeBpsDataRequest.cc
+	src/model/DescribeScdnDomainRealTimeBpsDataResult.cc
 	src/model/SetScdnDomainCertificateRequest.cc
 	src/model/SetScdnDomainCertificateResult.cc
 	src/model/BatchDeleteScdnDomainConfigsRequest.cc
 	src/model/BatchDeleteScdnDomainConfigsResult.cc
+	src/model/DescribeScdnDomainRealTimeSrcTrafficDataRequest.cc
+	src/model/DescribeScdnDomainRealTimeSrcTrafficDataResult.cc
+	src/model/DescribeScdnTopDomainsByFlowRequest.cc
+	src/model/DescribeScdnTopDomainsByFlowResult.cc
 	src/model/DescribeScdnDomainBpsDataRequest.cc
 	src/model/DescribeScdnDomainBpsDataResult.cc
 	src/model/PreloadScdnObjectCachesRequest.cc
@@ -144,18 +188,34 @@ set(scdn_src
 	src/model/DescribeScdnDomainHttpCodeDataResult.cc
 	src/model/RefreshScdnObjectCachesRequest.cc
 	src/model/RefreshScdnObjectCachesResult.cc
+	src/model/DescribeScdnDomainRealTimeTrafficDataRequest.cc
+	src/model/DescribeScdnDomainRealTimeTrafficDataResult.cc
+	src/model/DescribeScdnDomainRealTimeQpsDataRequest.cc
+	src/model/DescribeScdnDomainRealTimeQpsDataResult.cc
 	src/model/DescribeScdnDomainCertificateInfoRequest.cc
 	src/model/DescribeScdnDomainCertificateInfoResult.cc
+	src/model/DescribeScdnDomainRealTimeHttpCodeDataRequest.cc
+	src/model/DescribeScdnDomainRealTimeHttpCodeDataResult.cc
 	src/model/CheckScdnServiceRequest.cc
 	src/model/CheckScdnServiceResult.cc
+	src/model/BatchUpdateScdnDomainRequest.cc
+	src/model/BatchUpdateScdnDomainResult.cc
 	src/model/UpdateScdnDomainRequest.cc
 	src/model/UpdateScdnDomainResult.cc
 	src/model/DescribeScdnDomainOriginTrafficDataRequest.cc
 	src/model/DescribeScdnDomainOriginTrafficDataResult.cc
+	src/model/DescribeScdnDomainRealTimeReqHitRateDataRequest.cc
+	src/model/DescribeScdnDomainRealTimeReqHitRateDataResult.cc
+	src/model/DescribeScdnDomainRealTimeSrcBpsDataRequest.cc
+	src/model/DescribeScdnDomainRealTimeSrcBpsDataResult.cc
 	src/model/DescribeScdnDomainIspDataRequest.cc
 	src/model/DescribeScdnDomainIspDataResult.cc
 	src/model/DescribeScdnRefreshTasksRequest.cc
-	src/model/DescribeScdnRefreshTasksResult.cc )
+	src/model/DescribeScdnRefreshTasksResult.cc
+	src/model/OpenScdnServiceRequest.cc
+	src/model/OpenScdnServiceResult.cc
+	src/model/DescribeScdnDomainTopUrlVisitRequest.cc
+	src/model/DescribeScdnDomainTopUrlVisitResult.cc )
 
 add_library(scdn ${LIB_TYPE}
 	${scdn_public_header}

scdn/include/alibabacloud/scdn/ScdnClient.h

@@ -24,26 +24,40 @@
 #include "ScdnExport.h"
 #include "model/DescribeScdnRefreshQuotaRequest.h"
 #include "model/DescribeScdnRefreshQuotaResult.h"
+#include "model/DescribeScdnDomainRealTimeByteHitRateDataRequest.h"
+#include "model/DescribeScdnDomainRealTimeByteHitRateDataResult.h"
 #include "model/DescribeScdnDomainTrafficDataRequest.h"
 #include "model/DescribeScdnDomainTrafficDataResult.h"
 #include "model/DescribeScdnDomainDetailRequest.h"
 #include "model/DescribeScdnDomainDetailResult.h"
+#include "model/SetDomainServerCertificateRequest.h"
+#include "model/SetDomainServerCertificateResult.h"
 #include "model/DescribeScdnDomainOriginBpsDataRequest.h"
 #include "model/DescribeScdnDomainOriginBpsDataResult.h"
 #include "model/DescribeScdnCertificateListRequest.h"
 #include "model/DescribeScdnCertificateListResult.h"
 #include "model/DescribeScdnDomainQpsDataRequest.h"
 #include "model/DescribeScdnDomainQpsDataResult.h"
+#include "model/DescribeScdnDomainTopReferVisitRequest.h"
+#include "model/DescribeScdnDomainTopReferVisitResult.h"
 #include "model/DescribeScdnDomainUvDataRequest.h"
 #include "model/DescribeScdnDomainUvDataResult.h"
+#include "model/DescribeScdnDomainRegionDataRequest.h"
+#include "model/DescribeScdnDomainRegionDataResult.h"
 #include "model/DescribeScdnIpInfoRequest.h"
 #include "model/DescribeScdnIpInfoResult.h"
 #include "model/DescribeScdnDomainConfigsRequest.h"
 #include "model/DescribeScdnDomainConfigsResult.h"
+#include "model/DescribeScdnDomainRealTimeBpsDataRequest.h"
+#include "model/DescribeScdnDomainRealTimeBpsDataResult.h"
 #include "model/SetScdnDomainCertificateRequest.h"
 #include "model/SetScdnDomainCertificateResult.h"
 #include "model/BatchDeleteScdnDomainConfigsRequest.h"
 #include "model/BatchDeleteScdnDomainConfigsResult.h"
+#include "model/DescribeScdnDomainRealTimeSrcTrafficDataRequest.h"
+#include "model/DescribeScdnDomainRealTimeSrcTrafficDataResult.h"
+#include "model/DescribeScdnTopDomainsByFlowRequest.h"
+#include "model/DescribeScdnTopDomainsByFlowResult.h"
 #include "model/DescribeScdnDomainBpsDataRequest.h"
 #include "model/DescribeScdnDomainBpsDataResult.h"
 #include "model/PreloadScdnObjectCachesRequest.h"
@@ -76,18 +90,34 @@
 #include "model/DescribeScdnDomainHttpCodeDataResult.h"
 #include "model/RefreshScdnObjectCachesRequest.h"
 #include "model/RefreshScdnObjectCachesResult.h"
+#include "model/DescribeScdnDomainRealTimeTrafficDataRequest.h"
+#include "model/DescribeScdnDomainRealTimeTrafficDataResult.h"
+#include "model/DescribeScdnDomainRealTimeQpsDataRequest.h"
+#include "model/DescribeScdnDomainRealTimeQpsDataResult.h"
 #include "model/DescribeScdnDomainCertificateInfoRequest.h"
 #include "model/DescribeScdnDomainCertificateInfoResult.h"
+#include "model/DescribeScdnDomainRealTimeHttpCodeDataRequest.h"
+#include "model/DescribeScdnDomainRealTimeHttpCodeDataResult.h"
 #include "model/CheckScdnServiceRequest.h"
 #include "model/CheckScdnServiceResult.h"
+#include "model/BatchUpdateScdnDomainRequest.h"
+#include "model/BatchUpdateScdnDomainResult.h"
 #include "model/UpdateScdnDomainRequest.h"
 #include "model/UpdateScdnDomainResult.h"
 #include "model/DescribeScdnDomainOriginTrafficDataRequest.h"
 #include "model/DescribeScdnDomainOriginTrafficDataResult.h"
+#include "model/DescribeScdnDomainRealTimeReqHitRateDataRequest.h"
+#include "model/DescribeScdnDomainRealTimeReqHitRateDataResult.h"
+#include "model/DescribeScdnDomainRealTimeSrcBpsDataRequest.h"
+#include "model/DescribeScdnDomainRealTimeSrcBpsDataResult.h"
 #include "model/DescribeScdnDomainIspDataRequest.h"
 #include "model/DescribeScdnDomainIspDataResult.h"
 #include "model/DescribeScdnRefreshTasksRequest.h"
 #include "model/DescribeScdnRefreshTasksResult.h"
+#include "model/OpenScdnServiceRequest.h"
+#include "model/OpenScdnServiceResult.h"
+#include "model/DescribeScdnDomainTopUrlVisitRequest.h"
+#include "model/DescribeScdnDomainTopUrlVisitResult.h"
 
 
 namespace AlibabaCloud
@@ -100,12 +130,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeScdnRefreshQuotaResult> DescribeScdnRefreshQuotaOutcome;
 			typedef std::future<DescribeScdnRefreshQuotaOutcome> DescribeScdnRefreshQuotaOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnRefreshQuotaRequest&, const DescribeScdnRefreshQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnRefreshQuotaAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainRealTimeByteHitRateDataResult> DescribeScdnDomainRealTimeByteHitRateDataOutcome;
+			typedef std::future<DescribeScdnDomainRealTimeByteHitRateDataOutcome> DescribeScdnDomainRealTimeByteHitRateDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainRealTimeByteHitRateDataRequest&, const DescribeScdnDomainRealTimeByteHitRateDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainRealTimeByteHitRateDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScdnDomainTrafficDataResult> DescribeScdnDomainTrafficDataOutcome;
 			typedef std::future<DescribeScdnDomainTrafficDataOutcome> DescribeScdnDomainTrafficDataOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainTrafficDataRequest&, const DescribeScdnDomainTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainTrafficDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScdnDomainDetailResult> DescribeScdnDomainDetailOutcome;
 			typedef std::future<DescribeScdnDomainDetailOutcome> DescribeScdnDomainDetailOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainDetailRequest&, const DescribeScdnDomainDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainDetailAsyncHandler;
+			typedef Outcome<Error, Model::SetDomainServerCertificateResult> SetDomainServerCertificateOutcome;
+			typedef std::future<SetDomainServerCertificateOutcome> SetDomainServerCertificateOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::SetDomainServerCertificateRequest&, const SetDomainServerCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDomainServerCertificateAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScdnDomainOriginBpsDataResult> DescribeScdnDomainOriginBpsDataOutcome;
 			typedef std::future<DescribeScdnDomainOriginBpsDataOutcome> DescribeScdnDomainOriginBpsDataOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainOriginBpsDataRequest&, const DescribeScdnDomainOriginBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainOriginBpsDataAsyncHandler;
@@ -115,21 +151,36 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeScdnDomainQpsDataResult> DescribeScdnDomainQpsDataOutcome;
 			typedef std::future<DescribeScdnDomainQpsDataOutcome> DescribeScdnDomainQpsDataOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainQpsDataRequest&, const DescribeScdnDomainQpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainQpsDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainTopReferVisitResult> DescribeScdnDomainTopReferVisitOutcome;
+			typedef std::future<DescribeScdnDomainTopReferVisitOutcome> DescribeScdnDomainTopReferVisitOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainTopReferVisitRequest&, const DescribeScdnDomainTopReferVisitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainTopReferVisitAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScdnDomainUvDataResult> DescribeScdnDomainUvDataOutcome;
 			typedef std::future<DescribeScdnDomainUvDataOutcome> DescribeScdnDomainUvDataOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainUvDataRequest&, const DescribeScdnDomainUvDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainUvDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainRegionDataResult> DescribeScdnDomainRegionDataOutcome;
+			typedef std::future<DescribeScdnDomainRegionDataOutcome> DescribeScdnDomainRegionDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainRegionDataRequest&, const DescribeScdnDomainRegionDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainRegionDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScdnIpInfoResult> DescribeScdnIpInfoOutcome;
 			typedef std::future<DescribeScdnIpInfoOutcome> DescribeScdnIpInfoOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnIpInfoRequest&, const DescribeScdnIpInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnIpInfoAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScdnDomainConfigsResult> DescribeScdnDomainConfigsOutcome;
 			typedef std::future<DescribeScdnDomainConfigsOutcome> DescribeScdnDomainConfigsOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainConfigsRequest&, const DescribeScdnDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainConfigsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainRealTimeBpsDataResult> DescribeScdnDomainRealTimeBpsDataOutcome;
+			typedef std::future<DescribeScdnDomainRealTimeBpsDataOutcome> DescribeScdnDomainRealTimeBpsDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainRealTimeBpsDataRequest&, const DescribeScdnDomainRealTimeBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainRealTimeBpsDataAsyncHandler;
 			typedef Outcome<Error, Model::SetScdnDomainCertificateResult> SetScdnDomainCertificateOutcome;
 			typedef std::future<SetScdnDomainCertificateOutcome> SetScdnDomainCertificateOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::SetScdnDomainCertificateRequest&, const SetScdnDomainCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetScdnDomainCertificateAsyncHandler;
 			typedef Outcome<Error, Model::BatchDeleteScdnDomainConfigsResult> BatchDeleteScdnDomainConfigsOutcome;
 			typedef std::future<BatchDeleteScdnDomainConfigsOutcome> BatchDeleteScdnDomainConfigsOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::BatchDeleteScdnDomainConfigsRequest&, const BatchDeleteScdnDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchDeleteScdnDomainConfigsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainRealTimeSrcTrafficDataResult> DescribeScdnDomainRealTimeSrcTrafficDataOutcome;
+			typedef std::future<DescribeScdnDomainRealTimeSrcTrafficDataOutcome> DescribeScdnDomainRealTimeSrcTrafficDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainRealTimeSrcTrafficDataRequest&, const DescribeScdnDomainRealTimeSrcTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainRealTimeSrcTrafficDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnTopDomainsByFlowResult> DescribeScdnTopDomainsByFlowOutcome;
+			typedef std::future<DescribeScdnTopDomainsByFlowOutcome> DescribeScdnTopDomainsByFlowOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnTopDomainsByFlowRequest&, const DescribeScdnTopDomainsByFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnTopDomainsByFlowAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScdnDomainBpsDataResult> DescribeScdnDomainBpsDataOutcome;
 			typedef std::future<DescribeScdnDomainBpsDataOutcome> DescribeScdnDomainBpsDataOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainBpsDataRequest&, const DescribeScdnDomainBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainBpsDataAsyncHandler;
@@ -178,24 +229,48 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RefreshScdnObjectCachesResult> RefreshScdnObjectCachesOutcome;
 			typedef std::future<RefreshScdnObjectCachesOutcome> RefreshScdnObjectCachesOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::RefreshScdnObjectCachesRequest&, const RefreshScdnObjectCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RefreshScdnObjectCachesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainRealTimeTrafficDataResult> DescribeScdnDomainRealTimeTrafficDataOutcome;
+			typedef std::future<DescribeScdnDomainRealTimeTrafficDataOutcome> DescribeScdnDomainRealTimeTrafficDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainRealTimeTrafficDataRequest&, const DescribeScdnDomainRealTimeTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainRealTimeTrafficDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainRealTimeQpsDataResult> DescribeScdnDomainRealTimeQpsDataOutcome;
+			typedef std::future<DescribeScdnDomainRealTimeQpsDataOutcome> DescribeScdnDomainRealTimeQpsDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainRealTimeQpsDataRequest&, const DescribeScdnDomainRealTimeQpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainRealTimeQpsDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScdnDomainCertificateInfoResult> DescribeScdnDomainCertificateInfoOutcome;
 			typedef std::future<DescribeScdnDomainCertificateInfoOutcome> DescribeScdnDomainCertificateInfoOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainCertificateInfoRequest&, const DescribeScdnDomainCertificateInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainCertificateInfoAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainRealTimeHttpCodeDataResult> DescribeScdnDomainRealTimeHttpCodeDataOutcome;
+			typedef std::future<DescribeScdnDomainRealTimeHttpCodeDataOutcome> DescribeScdnDomainRealTimeHttpCodeDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainRealTimeHttpCodeDataRequest&, const DescribeScdnDomainRealTimeHttpCodeDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainRealTimeHttpCodeDataAsyncHandler;
 			typedef Outcome<Error, Model::CheckScdnServiceResult> CheckScdnServiceOutcome;
 			typedef std::future<CheckScdnServiceOutcome> CheckScdnServiceOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::CheckScdnServiceRequest&, const CheckScdnServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckScdnServiceAsyncHandler;
+			typedef Outcome<Error, Model::BatchUpdateScdnDomainResult> BatchUpdateScdnDomainOutcome;
+			typedef std::future<BatchUpdateScdnDomainOutcome> BatchUpdateScdnDomainOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::BatchUpdateScdnDomainRequest&, const BatchUpdateScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchUpdateScdnDomainAsyncHandler;
 			typedef Outcome<Error, Model::UpdateScdnDomainResult> UpdateScdnDomainOutcome;
 			typedef std::future<UpdateScdnDomainOutcome> UpdateScdnDomainOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::UpdateScdnDomainRequest&, const UpdateScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateScdnDomainAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScdnDomainOriginTrafficDataResult> DescribeScdnDomainOriginTrafficDataOutcome;
 			typedef std::future<DescribeScdnDomainOriginTrafficDataOutcome> DescribeScdnDomainOriginTrafficDataOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainOriginTrafficDataRequest&, const DescribeScdnDomainOriginTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainOriginTrafficDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainRealTimeReqHitRateDataResult> DescribeScdnDomainRealTimeReqHitRateDataOutcome;
+			typedef std::future<DescribeScdnDomainRealTimeReqHitRateDataOutcome> DescribeScdnDomainRealTimeReqHitRateDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainRealTimeReqHitRateDataRequest&, const DescribeScdnDomainRealTimeReqHitRateDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainRealTimeReqHitRateDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainRealTimeSrcBpsDataResult> DescribeScdnDomainRealTimeSrcBpsDataOutcome;
+			typedef std::future<DescribeScdnDomainRealTimeSrcBpsDataOutcome> DescribeScdnDomainRealTimeSrcBpsDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainRealTimeSrcBpsDataRequest&, const DescribeScdnDomainRealTimeSrcBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainRealTimeSrcBpsDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScdnDomainIspDataResult> DescribeScdnDomainIspDataOutcome;
 			typedef std::future<DescribeScdnDomainIspDataOutcome> DescribeScdnDomainIspDataOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainIspDataRequest&, const DescribeScdnDomainIspDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainIspDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeScdnRefreshTasksResult> DescribeScdnRefreshTasksOutcome;
 			typedef std::future<DescribeScdnRefreshTasksOutcome> DescribeScdnRefreshTasksOutcomeCallable;
 			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnRefreshTasksRequest&, const DescribeScdnRefreshTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnRefreshTasksAsyncHandler;
+			typedef Outcome<Error, Model::OpenScdnServiceResult> OpenScdnServiceOutcome;
+			typedef std::future<OpenScdnServiceOutcome> OpenScdnServiceOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::OpenScdnServiceRequest&, const OpenScdnServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> OpenScdnServiceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainTopUrlVisitResult> DescribeScdnDomainTopUrlVisitOutcome;
+			typedef std::future<DescribeScdnDomainTopUrlVisitOutcome> DescribeScdnDomainTopUrlVisitOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainTopUrlVisitRequest&, const DescribeScdnDomainTopUrlVisitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainTopUrlVisitAsyncHandler;
 
 			ScdnClient(const Credentials &credentials, const ClientConfiguration &configuration);
 			ScdnClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
@@ -204,12 +279,18 @@ namespace AlibabaCloud
 			DescribeScdnRefreshQuotaOutcome describeScdnRefreshQuota(const Model::DescribeScdnRefreshQuotaRequest &request)const;
 			void describeScdnRefreshQuotaAsync(const Model::DescribeScdnRefreshQuotaRequest& request, const DescribeScdnRefreshQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnRefreshQuotaOutcomeCallable describeScdnRefreshQuotaCallable(const Model::DescribeScdnRefreshQuotaRequest& request) const;
+			DescribeScdnDomainRealTimeByteHitRateDataOutcome describeScdnDomainRealTimeByteHitRateData(const Model::DescribeScdnDomainRealTimeByteHitRateDataRequest &request)const;
+			void describeScdnDomainRealTimeByteHitRateDataAsync(const Model::DescribeScdnDomainRealTimeByteHitRateDataRequest& request, const DescribeScdnDomainRealTimeByteHitRateDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainRealTimeByteHitRateDataOutcomeCallable describeScdnDomainRealTimeByteHitRateDataCallable(const Model::DescribeScdnDomainRealTimeByteHitRateDataRequest& request) const;
 			DescribeScdnDomainTrafficDataOutcome describeScdnDomainTrafficData(const Model::DescribeScdnDomainTrafficDataRequest &request)const;
 			void describeScdnDomainTrafficDataAsync(const Model::DescribeScdnDomainTrafficDataRequest& request, const DescribeScdnDomainTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnDomainTrafficDataOutcomeCallable describeScdnDomainTrafficDataCallable(const Model::DescribeScdnDomainTrafficDataRequest& request) const;
 			DescribeScdnDomainDetailOutcome describeScdnDomainDetail(const Model::DescribeScdnDomainDetailRequest &request)const;
 			void describeScdnDomainDetailAsync(const Model::DescribeScdnDomainDetailRequest& request, const DescribeScdnDomainDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnDomainDetailOutcomeCallable describeScdnDomainDetailCallable(const Model::DescribeScdnDomainDetailRequest& request) const;
+			SetDomainServerCertificateOutcome setDomainServerCertificate(const Model::SetDomainServerCertificateRequest &request)const;
+			void setDomainServerCertificateAsync(const Model::SetDomainServerCertificateRequest& request, const SetDomainServerCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetDomainServerCertificateOutcomeCallable setDomainServerCertificateCallable(const Model::SetDomainServerCertificateRequest& request) const;
 			DescribeScdnDomainOriginBpsDataOutcome describeScdnDomainOriginBpsData(const Model::DescribeScdnDomainOriginBpsDataRequest &request)const;
 			void describeScdnDomainOriginBpsDataAsync(const Model::DescribeScdnDomainOriginBpsDataRequest& request, const DescribeScdnDomainOriginBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnDomainOriginBpsDataOutcomeCallable describeScdnDomainOriginBpsDataCallable(const Model::DescribeScdnDomainOriginBpsDataRequest& request) const;
@@ -219,21 +300,36 @@ namespace AlibabaCloud
 			DescribeScdnDomainQpsDataOutcome describeScdnDomainQpsData(const Model::DescribeScdnDomainQpsDataRequest &request)const;
 			void describeScdnDomainQpsDataAsync(const Model::DescribeScdnDomainQpsDataRequest& request, const DescribeScdnDomainQpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnDomainQpsDataOutcomeCallable describeScdnDomainQpsDataCallable(const Model::DescribeScdnDomainQpsDataRequest& request) const;
+			DescribeScdnDomainTopReferVisitOutcome describeScdnDomainTopReferVisit(const Model::DescribeScdnDomainTopReferVisitRequest &request)const;
+			void describeScdnDomainTopReferVisitAsync(const Model::DescribeScdnDomainTopReferVisitRequest& request, const DescribeScdnDomainTopReferVisitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainTopReferVisitOutcomeCallable describeScdnDomainTopReferVisitCallable(const Model::DescribeScdnDomainTopReferVisitRequest& request) const;
 			DescribeScdnDomainUvDataOutcome describeScdnDomainUvData(const Model::DescribeScdnDomainUvDataRequest &request)const;
 			void describeScdnDomainUvDataAsync(const Model::DescribeScdnDomainUvDataRequest& request, const DescribeScdnDomainUvDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnDomainUvDataOutcomeCallable describeScdnDomainUvDataCallable(const Model::DescribeScdnDomainUvDataRequest& request) const;
+			DescribeScdnDomainRegionDataOutcome describeScdnDomainRegionData(const Model::DescribeScdnDomainRegionDataRequest &request)const;
+			void describeScdnDomainRegionDataAsync(const Model::DescribeScdnDomainRegionDataRequest& request, const DescribeScdnDomainRegionDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainRegionDataOutcomeCallable describeScdnDomainRegionDataCallable(const Model::DescribeScdnDomainRegionDataRequest& request) const;
 			DescribeScdnIpInfoOutcome describeScdnIpInfo(const Model::DescribeScdnIpInfoRequest &request)const;
 			void describeScdnIpInfoAsync(const Model::DescribeScdnIpInfoRequest& request, const DescribeScdnIpInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnIpInfoOutcomeCallable describeScdnIpInfoCallable(const Model::DescribeScdnIpInfoRequest& request) const;
 			DescribeScdnDomainConfigsOutcome describeScdnDomainConfigs(const Model::DescribeScdnDomainConfigsRequest &request)const;
 			void describeScdnDomainConfigsAsync(const Model::DescribeScdnDomainConfigsRequest& request, const DescribeScdnDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnDomainConfigsOutcomeCallable describeScdnDomainConfigsCallable(const Model::DescribeScdnDomainConfigsRequest& request) const;
+			DescribeScdnDomainRealTimeBpsDataOutcome describeScdnDomainRealTimeBpsData(const Model::DescribeScdnDomainRealTimeBpsDataRequest &request)const;
+			void describeScdnDomainRealTimeBpsDataAsync(const Model::DescribeScdnDomainRealTimeBpsDataRequest& request, const DescribeScdnDomainRealTimeBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainRealTimeBpsDataOutcomeCallable describeScdnDomainRealTimeBpsDataCallable(const Model::DescribeScdnDomainRealTimeBpsDataRequest& request) const;
 			SetScdnDomainCertificateOutcome setScdnDomainCertificate(const Model::SetScdnDomainCertificateRequest &request)const;
 			void setScdnDomainCertificateAsync(const Model::SetScdnDomainCertificateRequest& request, const SetScdnDomainCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetScdnDomainCertificateOutcomeCallable setScdnDomainCertificateCallable(const Model::SetScdnDomainCertificateRequest& request) const;
 			BatchDeleteScdnDomainConfigsOutcome batchDeleteScdnDomainConfigs(const Model::BatchDeleteScdnDomainConfigsRequest &request)const;
 			void batchDeleteScdnDomainConfigsAsync(const Model::BatchDeleteScdnDomainConfigsRequest& request, const BatchDeleteScdnDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			BatchDeleteScdnDomainConfigsOutcomeCallable batchDeleteScdnDomainConfigsCallable(const Model::BatchDeleteScdnDomainConfigsRequest& request) const;
+			DescribeScdnDomainRealTimeSrcTrafficDataOutcome describeScdnDomainRealTimeSrcTrafficData(const Model::DescribeScdnDomainRealTimeSrcTrafficDataRequest &request)const;
+			void describeScdnDomainRealTimeSrcTrafficDataAsync(const Model::DescribeScdnDomainRealTimeSrcTrafficDataRequest& request, const DescribeScdnDomainRealTimeSrcTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainRealTimeSrcTrafficDataOutcomeCallable describeScdnDomainRealTimeSrcTrafficDataCallable(const Model::DescribeScdnDomainRealTimeSrcTrafficDataRequest& request) const;
+			DescribeScdnTopDomainsByFlowOutcome describeScdnTopDomainsByFlow(const Model::DescribeScdnTopDomainsByFlowRequest &request)const;
+			void describeScdnTopDomainsByFlowAsync(const Model::DescribeScdnTopDomainsByFlowRequest& request, const DescribeScdnTopDomainsByFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnTopDomainsByFlowOutcomeCallable describeScdnTopDomainsByFlowCallable(const Model::DescribeScdnTopDomainsByFlowRequest& request) const;
 			DescribeScdnDomainBpsDataOutcome describeScdnDomainBpsData(const Model::DescribeScdnDomainBpsDataRequest &request)const;
 			void describeScdnDomainBpsDataAsync(const Model::DescribeScdnDomainBpsDataRequest& request, const DescribeScdnDomainBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnDomainBpsDataOutcomeCallable describeScdnDomainBpsDataCallable(const Model::DescribeScdnDomainBpsDataRequest& request) const;
@@ -282,24 +378,48 @@ namespace AlibabaCloud
 			RefreshScdnObjectCachesOutcome refreshScdnObjectCaches(const Model::RefreshScdnObjectCachesRequest &request)const;
 			void refreshScdnObjectCachesAsync(const Model::RefreshScdnObjectCachesRequest& request, const RefreshScdnObjectCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RefreshScdnObjectCachesOutcomeCallable refreshScdnObjectCachesCallable(const Model::RefreshScdnObjectCachesRequest& request) const;
+			DescribeScdnDomainRealTimeTrafficDataOutcome describeScdnDomainRealTimeTrafficData(const Model::DescribeScdnDomainRealTimeTrafficDataRequest &request)const;
+			void describeScdnDomainRealTimeTrafficDataAsync(const Model::DescribeScdnDomainRealTimeTrafficDataRequest& request, const DescribeScdnDomainRealTimeTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainRealTimeTrafficDataOutcomeCallable describeScdnDomainRealTimeTrafficDataCallable(const Model::DescribeScdnDomainRealTimeTrafficDataRequest& request) const;
+			DescribeScdnDomainRealTimeQpsDataOutcome describeScdnDomainRealTimeQpsData(const Model::DescribeScdnDomainRealTimeQpsDataRequest &request)const;
+			void describeScdnDomainRealTimeQpsDataAsync(const Model::DescribeScdnDomainRealTimeQpsDataRequest& request, const DescribeScdnDomainRealTimeQpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainRealTimeQpsDataOutcomeCallable describeScdnDomainRealTimeQpsDataCallable(const Model::DescribeScdnDomainRealTimeQpsDataRequest& request) const;
 			DescribeScdnDomainCertificateInfoOutcome describeScdnDomainCertificateInfo(const Model::DescribeScdnDomainCertificateInfoRequest &request)const;
 			void describeScdnDomainCertificateInfoAsync(const Model::DescribeScdnDomainCertificateInfoRequest& request, const DescribeScdnDomainCertificateInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnDomainCertificateInfoOutcomeCallable describeScdnDomainCertificateInfoCallable(const Model::DescribeScdnDomainCertificateInfoRequest& request) const;
+			DescribeScdnDomainRealTimeHttpCodeDataOutcome describeScdnDomainRealTimeHttpCodeData(const Model::DescribeScdnDomainRealTimeHttpCodeDataRequest &request)const;
+			void describeScdnDomainRealTimeHttpCodeDataAsync(const Model::DescribeScdnDomainRealTimeHttpCodeDataRequest& request, const DescribeScdnDomainRealTimeHttpCodeDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainRealTimeHttpCodeDataOutcomeCallable describeScdnDomainRealTimeHttpCodeDataCallable(const Model::DescribeScdnDomainRealTimeHttpCodeDataRequest& request) const;
 			CheckScdnServiceOutcome checkScdnService(const Model::CheckScdnServiceRequest &request)const;
 			void checkScdnServiceAsync(const Model::CheckScdnServiceRequest& request, const CheckScdnServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CheckScdnServiceOutcomeCallable checkScdnServiceCallable(const Model::CheckScdnServiceRequest& request) const;
+			BatchUpdateScdnDomainOutcome batchUpdateScdnDomain(const Model::BatchUpdateScdnDomainRequest &request)const;
+			void batchUpdateScdnDomainAsync(const Model::BatchUpdateScdnDomainRequest& request, const BatchUpdateScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			BatchUpdateScdnDomainOutcomeCallable batchUpdateScdnDomainCallable(const Model::BatchUpdateScdnDomainRequest& request) const;
 			UpdateScdnDomainOutcome updateScdnDomain(const Model::UpdateScdnDomainRequest &request)const;
 			void updateScdnDomainAsync(const Model::UpdateScdnDomainRequest& request, const UpdateScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateScdnDomainOutcomeCallable updateScdnDomainCallable(const Model::UpdateScdnDomainRequest& request) const;
 			DescribeScdnDomainOriginTrafficDataOutcome describeScdnDomainOriginTrafficData(const Model::DescribeScdnDomainOriginTrafficDataRequest &request)const;
 			void describeScdnDomainOriginTrafficDataAsync(const Model::DescribeScdnDomainOriginTrafficDataRequest& request, const DescribeScdnDomainOriginTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnDomainOriginTrafficDataOutcomeCallable describeScdnDomainOriginTrafficDataCallable(const Model::DescribeScdnDomainOriginTrafficDataRequest& request) const;
+			DescribeScdnDomainRealTimeReqHitRateDataOutcome describeScdnDomainRealTimeReqHitRateData(const Model::DescribeScdnDomainRealTimeReqHitRateDataRequest &request)const;
+			void describeScdnDomainRealTimeReqHitRateDataAsync(const Model::DescribeScdnDomainRealTimeReqHitRateDataRequest& request, const DescribeScdnDomainRealTimeReqHitRateDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainRealTimeReqHitRateDataOutcomeCallable describeScdnDomainRealTimeReqHitRateDataCallable(const Model::DescribeScdnDomainRealTimeReqHitRateDataRequest& request) const;
+			DescribeScdnDomainRealTimeSrcBpsDataOutcome describeScdnDomainRealTimeSrcBpsData(const Model::DescribeScdnDomainRealTimeSrcBpsDataRequest &request)const;
+			void describeScdnDomainRealTimeSrcBpsDataAsync(const Model::DescribeScdnDomainRealTimeSrcBpsDataRequest& request, const DescribeScdnDomainRealTimeSrcBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainRealTimeSrcBpsDataOutcomeCallable describeScdnDomainRealTimeSrcBpsDataCallable(const Model::DescribeScdnDomainRealTimeSrcBpsDataRequest& request) const;
 			DescribeScdnDomainIspDataOutcome describeScdnDomainIspData(const Model::DescribeScdnDomainIspDataRequest &request)const;
 			void describeScdnDomainIspDataAsync(const Model::DescribeScdnDomainIspDataRequest& request, const DescribeScdnDomainIspDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnDomainIspDataOutcomeCallable describeScdnDomainIspDataCallable(const Model::DescribeScdnDomainIspDataRequest& request) const;
 			DescribeScdnRefreshTasksOutcome describeScdnRefreshTasks(const Model::DescribeScdnRefreshTasksRequest &request)const;
 			void describeScdnRefreshTasksAsync(const Model::DescribeScdnRefreshTasksRequest& request, const DescribeScdnRefreshTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeScdnRefreshTasksOutcomeCallable describeScdnRefreshTasksCallable(const Model::DescribeScdnRefreshTasksRequest& request) const;
+			OpenScdnServiceOutcome openScdnService(const Model::OpenScdnServiceRequest &request)const;
+			void openScdnServiceAsync(const Model::OpenScdnServiceRequest& request, const OpenScdnServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			OpenScdnServiceOutcomeCallable openScdnServiceCallable(const Model::OpenScdnServiceRequest& request) const;
+			DescribeScdnDomainTopUrlVisitOutcome describeScdnDomainTopUrlVisit(const Model::DescribeScdnDomainTopUrlVisitRequest &request)const;
+			void describeScdnDomainTopUrlVisitAsync(const Model::DescribeScdnDomainTopUrlVisitRequest& request, const DescribeScdnDomainTopUrlVisitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainTopUrlVisitOutcomeCallable describeScdnDomainTopUrlVisitCallable(const Model::DescribeScdnDomainTopUrlVisitRequest& request) const;
 	
 		private:
 			std::shared_ptr<EndpointProvider> endpointProvider_;

scdn/include/alibabacloud/scdn/model/BatchUpdateScdnDomainRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_BATCHUPDATESCDNDOMAINREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_BATCHUPDATESCDNDOMAINREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT BatchUpdateScdnDomainRequest : public RpcServiceRequest
+			{
+
+			public:
+				BatchUpdateScdnDomainRequest();
+				~BatchUpdateScdnDomainRequest();
+
+				std::string getTopLevelDomain()const;
+				void setTopLevelDomain(const std::string& topLevelDomain);
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
+				std::string getSources()const;
+				void setSources(const std::string& sources);
+				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 topLevelDomain_;
+				std::string resourceGroupId_;
+				std::string sources_;
+				std::string securityToken_;
+				std::string domainName_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_BATCHUPDATESCDNDOMAINREQUEST_H_

scdn/include/alibabacloud/scdn/model/BatchUpdateScdnDomainResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainBpsDataRequest.h

@@ -89,8 +89,6 @@ namespace AlibabaCloud
 				void setRequestId(const std::string& requestId);
 				std::string getInterval()const;
 				void setInterval(const std::string& interval);
-				std::string getFields()const;
-				void setFields(const std::string& fields);
 
             private:
 				long callerParentId_;
@@ -120,7 +118,6 @@ namespace AlibabaCloud
 				bool security_transport_;
 				std::string requestId_;
 				std::string interval_;
-				std::string fields_;
 
 			};
 		}

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainHttpCodeDataRequest.h

@@ -67,8 +67,6 @@ namespace AlibabaCloud
 				void setApp_ip(const std::string& app_ip);
 				std::string getPopProduct()const;
 				void setPopProduct(const std::string& popProduct);
-				std::string getProduct()const;
-				void setProduct(const std::string& product);
 				std::string getDomainName()const;
 				void setDomainName(const std::string& domainName);
 				std::string getEndTime()const;
@@ -109,7 +107,6 @@ namespace AlibabaCloud
 				long callerUid_;
 				std::string app_ip_;
 				std::string popProduct_;
-				std::string product_;
 				std::string domainName_;
 				std::string endTime_;
 				std::string callerBid_;

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainIspDataResult.h

@@ -32,7 +32,7 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainIspDataResult : public ServiceResult
 			{
 			public:
-				struct IspProportionData
+				struct ISPProportionData
 				{
 					std::string avgObjectSize;
 					std::string bytesProportion;
@@ -40,9 +40,10 @@ namespace AlibabaCloud
 					std::string proportion;
 					std::string qps;
 					std::string totalQuery;
-					std::string isp;
+					std::string iSP;
 					std::string totalBytes;
 					std::string avgResponseRate;
+					std::string reqErrRate;
 					std::string ispEname;
 					std::string avgResponseTime;
 				};
@@ -53,7 +54,7 @@ namespace AlibabaCloud
 				~DescribeScdnDomainIspDataResult();
 				std::string getEndTime()const;
 				std::string getDomainName()const;
-				std::vector<IspProportionData> getValue()const;
+				std::vector<ISPProportionData> getValue()const;
 				std::string getDataInterval()const;
 				std::string getStartTime()const;
 
@@ -62,7 +63,7 @@ namespace AlibabaCloud
 			private:
 				std::string endTime_;
 				std::string domainName_;
-				std::vector<IspProportionData> value_;
+				std::vector<ISPProportionData> value_;
 				std::string dataInterval_;
 				std::string startTime_;
 

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainQpsDataRequest.h

@@ -89,8 +89,6 @@ namespace AlibabaCloud
 				void setRequestId(const std::string& requestId);
 				std::string getInterval()const;
 				void setInterval(const std::string& interval);
-				std::string getFields()const;
-				void setFields(const std::string& fields);
 
             private:
 				long callerParentId_;
@@ -120,7 +118,6 @@ namespace AlibabaCloud
 				bool security_transport_;
 				std::string requestId_;
 				std::string interval_;
-				std::string fields_;
 
 			};
 		}

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeBpsDataRequest.h

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEBPSDATAREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEBPSDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainRealTimeBpsDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnDomainRealTimeBpsDataRequest();
+				~DescribeScdnDomainRealTimeBpsDataRequest();
+
+				long getCallerParentId()const;
+				void setCallerParentId(long callerParentId);
+				bool getProxy_original_security_transport()const;
+				void setProxy_original_security_transport(bool proxy_original_security_transport);
+				std::string getLocationNameEn()const;
+				void setLocationNameEn(const std::string& locationNameEn);
+				std::string getIspNameEn()const;
+				void setIspNameEn(const std::string& ispNameEn);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getProxy_original_source_ip()const;
+				void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
+				std::string getOwnerIdLoginEmail()const;
+				void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
+				std::string getCallerType()const;
+				void setCallerType(const std::string& callerType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRequestContent()const;
+				void setRequestContent(const std::string& requestContent);
+				std::string getCallerBidEmail()const;
+				void setCallerBidEmail(const std::string& callerBidEmail);
+				std::string getCallerUidEmail()const;
+				void setCallerUidEmail(const std::string& callerUidEmail);
+				long getCallerUid()const;
+				void setCallerUid(long callerUid);
+				std::string getApp_ip()const;
+				void setApp_ip(const std::string& app_ip);
+				std::string getPopProduct()const;
+				void setPopProduct(const std::string& popProduct);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getCallerBid()const;
+				void setCallerBid(const std::string& callerBid);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVersion()const;
+				void setVersion(const std::string& version);
+				bool getProxy_trust_transport_info()const;
+				void setProxy_trust_transport_info(bool proxy_trust_transport_info);
+				bool getAk_mfa_present()const;
+				void setAk_mfa_present(bool ak_mfa_present);
+				bool getSecurity_transport()const;
+				void setSecurity_transport(bool security_transport);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+
+            private:
+				long callerParentId_;
+				bool proxy_original_security_transport_;
+				std::string locationNameEn_;
+				std::string ispNameEn_;
+				std::string startTime_;
+				std::string proxy_original_source_ip_;
+				std::string ownerIdLoginEmail_;
+				std::string callerType_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string requestContent_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string product_;
+				std::string domainName_;
+				std::string endTime_;
+				std::string callerBid_;
+				long ownerId_;
+				std::string version_;
+				bool proxy_trust_transport_info_;
+				bool ak_mfa_present_;
+				bool security_transport_;
+				std::string requestId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEBPSDATAREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeBpsDataResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeByteHitRateDataRequest.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEBYTEHITRATEDATAREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEBYTEHITRATEDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainRealTimeByteHitRateDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnDomainRealTimeByteHitRateDataRequest();
+				~DescribeScdnDomainRealTimeByteHitRateDataRequest();
+
+				long getCallerParentId()const;
+				void setCallerParentId(long callerParentId);
+				bool getProxy_original_security_transport()const;
+				void setProxy_original_security_transport(bool proxy_original_security_transport);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getProxy_original_source_ip()const;
+				void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
+				std::string getOwnerIdLoginEmail()const;
+				void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
+				std::string getCallerType()const;
+				void setCallerType(const std::string& callerType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRequestContent()const;
+				void setRequestContent(const std::string& requestContent);
+				std::string getCallerBidEmail()const;
+				void setCallerBidEmail(const std::string& callerBidEmail);
+				std::string getCallerUidEmail()const;
+				void setCallerUidEmail(const std::string& callerUidEmail);
+				long getCallerUid()const;
+				void setCallerUid(long callerUid);
+				std::string getApp_ip()const;
+				void setApp_ip(const std::string& app_ip);
+				std::string getPopProduct()const;
+				void setPopProduct(const std::string& popProduct);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getCallerBid()const;
+				void setCallerBid(const std::string& callerBid);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVersion()const;
+				void setVersion(const std::string& version);
+				bool getProxy_trust_transport_info()const;
+				void setProxy_trust_transport_info(bool proxy_trust_transport_info);
+				bool getAk_mfa_present()const;
+				void setAk_mfa_present(bool ak_mfa_present);
+				bool getSecurity_transport()const;
+				void setSecurity_transport(bool security_transport);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+
+            private:
+				long callerParentId_;
+				bool proxy_original_security_transport_;
+				std::string startTime_;
+				std::string proxy_original_source_ip_;
+				std::string ownerIdLoginEmail_;
+				std::string callerType_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string requestContent_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string product_;
+				std::string domainName_;
+				std::string endTime_;
+				std::string callerBid_;
+				long ownerId_;
+				std::string version_;
+				bool proxy_trust_transport_info_;
+				bool ak_mfa_present_;
+				bool security_transport_;
+				std::string requestId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEBYTEHITRATEDATAREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeByteHitRateDataResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeHttpCodeDataRequest.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEHTTPCODEDATAREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEHTTPCODEDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainRealTimeHttpCodeDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnDomainRealTimeHttpCodeDataRequest();
+				~DescribeScdnDomainRealTimeHttpCodeDataRequest();
+
+				long getCallerParentId()const;
+				void setCallerParentId(long callerParentId);
+				bool getProxy_original_security_transport()const;
+				void setProxy_original_security_transport(bool proxy_original_security_transport);
+				std::string getLocationNameEn()const;
+				void setLocationNameEn(const std::string& locationNameEn);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getIspNameEn()const;
+				void setIspNameEn(const std::string& ispNameEn);
+				std::string getProxy_original_source_ip()const;
+				void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
+				std::string getOwnerIdLoginEmail()const;
+				void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
+				std::string getCallerType()const;
+				void setCallerType(const std::string& callerType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRequestContent()const;
+				void setRequestContent(const std::string& requestContent);
+				std::string getCallerBidEmail()const;
+				void setCallerBidEmail(const std::string& callerBidEmail);
+				std::string getCallerUidEmail()const;
+				void setCallerUidEmail(const std::string& callerUidEmail);
+				long getCallerUid()const;
+				void setCallerUid(long callerUid);
+				std::string getApp_ip()const;
+				void setApp_ip(const std::string& app_ip);
+				std::string getPopProduct()const;
+				void setPopProduct(const std::string& popProduct);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getCallerBid()const;
+				void setCallerBid(const std::string& callerBid);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVersion()const;
+				void setVersion(const std::string& version);
+				bool getProxy_trust_transport_info()const;
+				void setProxy_trust_transport_info(bool proxy_trust_transport_info);
+				bool getAk_mfa_present()const;
+				void setAk_mfa_present(bool ak_mfa_present);
+				bool getSecurity_transport()const;
+				void setSecurity_transport(bool security_transport);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+				std::string getFields()const;
+				void setFields(const std::string& fields);
+
+            private:
+				long callerParentId_;
+				bool proxy_original_security_transport_;
+				std::string locationNameEn_;
+				std::string startTime_;
+				std::string ispNameEn_;
+				std::string proxy_original_source_ip_;
+				std::string ownerIdLoginEmail_;
+				std::string callerType_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string requestContent_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string product_;
+				std::string domainName_;
+				std::string endTime_;
+				std::string callerBid_;
+				long ownerId_;
+				std::string version_;
+				bool proxy_trust_transport_info_;
+				bool ak_mfa_present_;
+				bool security_transport_;
+				std::string requestId_;
+				std::string interval_;
+				std::string fields_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEHTTPCODEDATAREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeHttpCodeDataResult.h

@@ -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_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEHTTPCODEDATARESULT_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEHTTPCODEDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainRealTimeHttpCodeDataResult : public ServiceResult
+			{
+			public:
+				struct UsageData
+				{
+					struct RealTimeCodeProportionData
+					{
+						std::string proportion;
+						std::string count;
+						std::string code;
+					};
+					std::vector<UsageData::RealTimeCodeProportionData> value;
+					std::string timeStamp;
+				};
+
+
+				DescribeScdnDomainRealTimeHttpCodeDataResult();
+				explicit DescribeScdnDomainRealTimeHttpCodeDataResult(const std::string &payload);
+				~DescribeScdnDomainRealTimeHttpCodeDataResult();
+				std::string getEndTime()const;
+				std::string getDomainName()const;
+				std::string getStartTime()const;
+				std::string getDataInterval()const;
+				std::vector<UsageData> getRealTimeHttpCodeData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				std::string domainName_;
+				std::string startTime_;
+				std::string dataInterval_;
+				std::vector<UsageData> realTimeHttpCodeData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEHTTPCODEDATARESULT_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeQpsDataRequest.h

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEQPSDATAREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEQPSDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainRealTimeQpsDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnDomainRealTimeQpsDataRequest();
+				~DescribeScdnDomainRealTimeQpsDataRequest();
+
+				long getCallerParentId()const;
+				void setCallerParentId(long callerParentId);
+				bool getProxy_original_security_transport()const;
+				void setProxy_original_security_transport(bool proxy_original_security_transport);
+				std::string getLocationNameEn()const;
+				void setLocationNameEn(const std::string& locationNameEn);
+				std::string getIspNameEn()const;
+				void setIspNameEn(const std::string& ispNameEn);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getProxy_original_source_ip()const;
+				void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
+				std::string getOwnerIdLoginEmail()const;
+				void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
+				std::string getCallerType()const;
+				void setCallerType(const std::string& callerType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRequestContent()const;
+				void setRequestContent(const std::string& requestContent);
+				std::string getCallerBidEmail()const;
+				void setCallerBidEmail(const std::string& callerBidEmail);
+				std::string getCallerUidEmail()const;
+				void setCallerUidEmail(const std::string& callerUidEmail);
+				long getCallerUid()const;
+				void setCallerUid(long callerUid);
+				std::string getApp_ip()const;
+				void setApp_ip(const std::string& app_ip);
+				std::string getPopProduct()const;
+				void setPopProduct(const std::string& popProduct);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getCallerBid()const;
+				void setCallerBid(const std::string& callerBid);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVersion()const;
+				void setVersion(const std::string& version);
+				bool getProxy_trust_transport_info()const;
+				void setProxy_trust_transport_info(bool proxy_trust_transport_info);
+				bool getAk_mfa_present()const;
+				void setAk_mfa_present(bool ak_mfa_present);
+				bool getSecurity_transport()const;
+				void setSecurity_transport(bool security_transport);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+
+            private:
+				long callerParentId_;
+				bool proxy_original_security_transport_;
+				std::string locationNameEn_;
+				std::string ispNameEn_;
+				std::string startTime_;
+				std::string proxy_original_source_ip_;
+				std::string ownerIdLoginEmail_;
+				std::string callerType_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string requestContent_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string product_;
+				std::string domainName_;
+				std::string endTime_;
+				std::string callerBid_;
+				long ownerId_;
+				std::string version_;
+				bool proxy_trust_transport_info_;
+				bool ak_mfa_present_;
+				bool security_transport_;
+				std::string requestId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEQPSDATAREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeQpsDataResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeReqHitRateDataRequest.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEREQHITRATEDATAREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEREQHITRATEDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainRealTimeReqHitRateDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnDomainRealTimeReqHitRateDataRequest();
+				~DescribeScdnDomainRealTimeReqHitRateDataRequest();
+
+				long getCallerParentId()const;
+				void setCallerParentId(long callerParentId);
+				bool getProxy_original_security_transport()const;
+				void setProxy_original_security_transport(bool proxy_original_security_transport);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getProxy_original_source_ip()const;
+				void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
+				std::string getOwnerIdLoginEmail()const;
+				void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
+				std::string getCallerType()const;
+				void setCallerType(const std::string& callerType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRequestContent()const;
+				void setRequestContent(const std::string& requestContent);
+				std::string getCallerBidEmail()const;
+				void setCallerBidEmail(const std::string& callerBidEmail);
+				std::string getCallerUidEmail()const;
+				void setCallerUidEmail(const std::string& callerUidEmail);
+				long getCallerUid()const;
+				void setCallerUid(long callerUid);
+				std::string getApp_ip()const;
+				void setApp_ip(const std::string& app_ip);
+				std::string getPopProduct()const;
+				void setPopProduct(const std::string& popProduct);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getCallerBid()const;
+				void setCallerBid(const std::string& callerBid);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVersion()const;
+				void setVersion(const std::string& version);
+				bool getProxy_trust_transport_info()const;
+				void setProxy_trust_transport_info(bool proxy_trust_transport_info);
+				bool getAk_mfa_present()const;
+				void setAk_mfa_present(bool ak_mfa_present);
+				bool getSecurity_transport()const;
+				void setSecurity_transport(bool security_transport);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+
+            private:
+				long callerParentId_;
+				bool proxy_original_security_transport_;
+				std::string startTime_;
+				std::string proxy_original_source_ip_;
+				std::string ownerIdLoginEmail_;
+				std::string callerType_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string requestContent_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string product_;
+				std::string domainName_;
+				std::string endTime_;
+				std::string callerBid_;
+				long ownerId_;
+				std::string version_;
+				bool proxy_trust_transport_info_;
+				bool ak_mfa_present_;
+				bool security_transport_;
+				std::string requestId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMEREQHITRATEDATAREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeReqHitRateDataResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcBpsDataRequest.h

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMESRCBPSDATAREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMESRCBPSDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainRealTimeSrcBpsDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnDomainRealTimeSrcBpsDataRequest();
+				~DescribeScdnDomainRealTimeSrcBpsDataRequest();
+
+				long getCallerParentId()const;
+				void setCallerParentId(long callerParentId);
+				bool getProxy_original_security_transport()const;
+				void setProxy_original_security_transport(bool proxy_original_security_transport);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getProxy_original_source_ip()const;
+				void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
+				std::string getOwnerIdLoginEmail()const;
+				void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
+				std::string getCallerType()const;
+				void setCallerType(const std::string& callerType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRequestContent()const;
+				void setRequestContent(const std::string& requestContent);
+				std::string getCallerBidEmail()const;
+				void setCallerBidEmail(const std::string& callerBidEmail);
+				std::string getCallerUidEmail()const;
+				void setCallerUidEmail(const std::string& callerUidEmail);
+				long getCallerUid()const;
+				void setCallerUid(long callerUid);
+				std::string getApp_ip()const;
+				void setApp_ip(const std::string& app_ip);
+				std::string getPopProduct()const;
+				void setPopProduct(const std::string& popProduct);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getCallerBid()const;
+				void setCallerBid(const std::string& callerBid);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVersion()const;
+				void setVersion(const std::string& version);
+				bool getProxy_trust_transport_info()const;
+				void setProxy_trust_transport_info(bool proxy_trust_transport_info);
+				bool getAk_mfa_present()const;
+				void setAk_mfa_present(bool ak_mfa_present);
+				bool getSecurity_transport()const;
+				void setSecurity_transport(bool security_transport);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+				std::string getFields()const;
+				void setFields(const std::string& fields);
+
+            private:
+				long callerParentId_;
+				bool proxy_original_security_transport_;
+				std::string startTime_;
+				std::string proxy_original_source_ip_;
+				std::string ownerIdLoginEmail_;
+				std::string callerType_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string requestContent_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string product_;
+				std::string domainName_;
+				std::string endTime_;
+				std::string callerBid_;
+				long ownerId_;
+				std::string version_;
+				bool proxy_trust_transport_info_;
+				bool ak_mfa_present_;
+				bool security_transport_;
+				std::string requestId_;
+				std::string interval_;
+				std::string fields_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMESRCBPSDATAREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcBpsDataResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcTrafficDataRequest.h

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMESRCTRAFFICDATAREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMESRCTRAFFICDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainRealTimeSrcTrafficDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnDomainRealTimeSrcTrafficDataRequest();
+				~DescribeScdnDomainRealTimeSrcTrafficDataRequest();
+
+				long getCallerParentId()const;
+				void setCallerParentId(long callerParentId);
+				bool getProxy_original_security_transport()const;
+				void setProxy_original_security_transport(bool proxy_original_security_transport);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getProxy_original_source_ip()const;
+				void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
+				std::string getOwnerIdLoginEmail()const;
+				void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
+				std::string getCallerType()const;
+				void setCallerType(const std::string& callerType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRequestContent()const;
+				void setRequestContent(const std::string& requestContent);
+				std::string getCallerBidEmail()const;
+				void setCallerBidEmail(const std::string& callerBidEmail);
+				std::string getCallerUidEmail()const;
+				void setCallerUidEmail(const std::string& callerUidEmail);
+				long getCallerUid()const;
+				void setCallerUid(long callerUid);
+				std::string getApp_ip()const;
+				void setApp_ip(const std::string& app_ip);
+				std::string getPopProduct()const;
+				void setPopProduct(const std::string& popProduct);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getCallerBid()const;
+				void setCallerBid(const std::string& callerBid);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVersion()const;
+				void setVersion(const std::string& version);
+				bool getProxy_trust_transport_info()const;
+				void setProxy_trust_transport_info(bool proxy_trust_transport_info);
+				bool getAk_mfa_present()const;
+				void setAk_mfa_present(bool ak_mfa_present);
+				bool getSecurity_transport()const;
+				void setSecurity_transport(bool security_transport);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+				std::string getFields()const;
+				void setFields(const std::string& fields);
+
+            private:
+				long callerParentId_;
+				bool proxy_original_security_transport_;
+				std::string startTime_;
+				std::string proxy_original_source_ip_;
+				std::string ownerIdLoginEmail_;
+				std::string callerType_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string requestContent_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string product_;
+				std::string domainName_;
+				std::string endTime_;
+				std::string callerBid_;
+				long ownerId_;
+				std::string version_;
+				bool proxy_trust_transport_info_;
+				bool ak_mfa_present_;
+				bool security_transport_;
+				std::string requestId_;
+				std::string interval_;
+				std::string fields_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMESRCTRAFFICDATAREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcTrafficDataResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeTrafficDataRequest.h

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMETRAFFICDATAREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMETRAFFICDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainRealTimeTrafficDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnDomainRealTimeTrafficDataRequest();
+				~DescribeScdnDomainRealTimeTrafficDataRequest();
+
+				long getCallerParentId()const;
+				void setCallerParentId(long callerParentId);
+				bool getProxy_original_security_transport()const;
+				void setProxy_original_security_transport(bool proxy_original_security_transport);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getProxy_original_source_ip()const;
+				void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
+				std::string getOwnerIdLoginEmail()const;
+				void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
+				std::string getCallerType()const;
+				void setCallerType(const std::string& callerType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRequestContent()const;
+				void setRequestContent(const std::string& requestContent);
+				std::string getCallerBidEmail()const;
+				void setCallerBidEmail(const std::string& callerBidEmail);
+				std::string getCallerUidEmail()const;
+				void setCallerUidEmail(const std::string& callerUidEmail);
+				long getCallerUid()const;
+				void setCallerUid(long callerUid);
+				std::string getApp_ip()const;
+				void setApp_ip(const std::string& app_ip);
+				std::string getPopProduct()const;
+				void setPopProduct(const std::string& popProduct);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getCallerBid()const;
+				void setCallerBid(const std::string& callerBid);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVersion()const;
+				void setVersion(const std::string& version);
+				bool getProxy_trust_transport_info()const;
+				void setProxy_trust_transport_info(bool proxy_trust_transport_info);
+				bool getAk_mfa_present()const;
+				void setAk_mfa_present(bool ak_mfa_present);
+				bool getSecurity_transport()const;
+				void setSecurity_transport(bool security_transport);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+				std::string getFields()const;
+				void setFields(const std::string& fields);
+
+            private:
+				long callerParentId_;
+				bool proxy_original_security_transport_;
+				std::string startTime_;
+				std::string proxy_original_source_ip_;
+				std::string ownerIdLoginEmail_;
+				std::string callerType_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string requestContent_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string product_;
+				std::string domainName_;
+				std::string endTime_;
+				std::string callerBid_;
+				long ownerId_;
+				std::string version_;
+				bool proxy_trust_transport_info_;
+				bool ak_mfa_present_;
+				bool security_transport_;
+				std::string requestId_;
+				std::string interval_;
+				std::string fields_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREALTIMETRAFFICDATAREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRealTimeTrafficDataResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRegionDataRequest.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREGIONDATAREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREGIONDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainRegionDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnDomainRegionDataRequest();
+				~DescribeScdnDomainRegionDataRequest();
+
+				long getCallerParentId()const;
+				void setCallerParentId(long callerParentId);
+				bool getProxy_original_security_transport()const;
+				void setProxy_original_security_transport(bool proxy_original_security_transport);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getProxy_original_source_ip()const;
+				void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
+				std::string getOwnerIdLoginEmail()const;
+				void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
+				std::string getCallerType()const;
+				void setCallerType(const std::string& callerType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRequestContent()const;
+				void setRequestContent(const std::string& requestContent);
+				std::string getCallerBidEmail()const;
+				void setCallerBidEmail(const std::string& callerBidEmail);
+				std::string getCallerUidEmail()const;
+				void setCallerUidEmail(const std::string& callerUidEmail);
+				long getCallerUid()const;
+				void setCallerUid(long callerUid);
+				std::string getApp_ip()const;
+				void setApp_ip(const std::string& app_ip);
+				std::string getPopProduct()const;
+				void setPopProduct(const std::string& popProduct);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getCallerBid()const;
+				void setCallerBid(const std::string& callerBid);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVersion()const;
+				void setVersion(const std::string& version);
+				bool getProxy_trust_transport_info()const;
+				void setProxy_trust_transport_info(bool proxy_trust_transport_info);
+				bool getAk_mfa_present()const;
+				void setAk_mfa_present(bool ak_mfa_present);
+				bool getSecurity_transport()const;
+				void setSecurity_transport(bool security_transport);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+
+            private:
+				long callerParentId_;
+				bool proxy_original_security_transport_;
+				std::string startTime_;
+				std::string proxy_original_source_ip_;
+				std::string ownerIdLoginEmail_;
+				std::string callerType_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string requestContent_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string product_;
+				std::string domainName_;
+				std::string endTime_;
+				std::string callerBid_;
+				long ownerId_;
+				std::string version_;
+				bool proxy_trust_transport_info_;
+				bool ak_mfa_present_;
+				bool security_transport_;
+				std::string requestId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREGIONDATAREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainRegionDataResult.h

@@ -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_SCDN_MODEL_DESCRIBESCDNDOMAINREGIONDATARESULT_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREGIONDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainRegionDataResult : public ServiceResult
+			{
+			public:
+				struct RegionProportionData
+				{
+					std::string avgObjectSize;
+					std::string bytesProportion;
+					std::string bps;
+					std::string proportion;
+					std::string qps;
+					std::string totalQuery;
+					std::string totalBytes;
+					std::string avgResponseRate;
+					std::string region;
+					std::string reqErrRate;
+					std::string regionEname;
+					std::string avgResponseTime;
+				};
+
+
+				DescribeScdnDomainRegionDataResult();
+				explicit DescribeScdnDomainRegionDataResult(const std::string &payload);
+				~DescribeScdnDomainRegionDataResult();
+				std::string getEndTime()const;
+				std::string getDomainName()const;
+				std::vector<RegionProportionData> getValue()const;
+				std::string getDataInterval()const;
+				std::string getStartTime()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				std::string domainName_;
+				std::vector<RegionProportionData> value_;
+				std::string dataInterval_;
+				std::string startTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINREGIONDATARESULT_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainTopReferVisitRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTOPREFERVISITREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTOPREFERVISITREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainTopReferVisitRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnDomainTopReferVisitRequest();
+				~DescribeScdnDomainTopReferVisitRequest();
+
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getSortBy()const;
+				void setSortBy(const std::string& sortBy);
+				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);
+
+            private:
+				std::string securityToken_;
+				std::string domainName_;
+				std::string sortBy_;
+				std::string startTime_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTOPREFERVISITREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainTopReferVisitResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainTopUrlVisitRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTOPURLVISITREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTOPURLVISITREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainTopUrlVisitRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnDomainTopUrlVisitRequest();
+				~DescribeScdnDomainTopUrlVisitRequest();
+
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getSortBy()const;
+				void setSortBy(const std::string& sortBy);
+				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);
+
+            private:
+				std::string securityToken_;
+				std::string domainName_;
+				std::string sortBy_;
+				std::string startTime_;
+				long ownerId_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTOPURLVISITREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainTopUrlVisitResult.h

@@ -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_SCDN_MODEL_DESCRIBESCDNDOMAINTOPURLVISITRESULT_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTOPURLVISITRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnDomainTopUrlVisitResult : public ServiceResult
+			{
+			public:
+				struct UrlList
+				{
+					std::string visitData;
+					float visitProportion;
+					float flowProportion;
+					std::string urlDetail;
+					std::string flow;
+				};
+
+
+				DescribeScdnDomainTopUrlVisitResult();
+				explicit DescribeScdnDomainTopUrlVisitResult(const std::string &payload);
+				~DescribeScdnDomainTopUrlVisitResult();
+				std::vector<UrlList> getUrl200List()const;
+				std::vector<UrlList> getUrl500List()const;
+				std::vector<UrlList> getUrl400List()const;
+				std::string getDomainName()const;
+				std::string getStartTime()const;
+				std::vector<UrlList> getUrl300List()const;
+				std::vector<UrlList> getAllUrlList()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<UrlList> url200List_;
+				std::vector<UrlList> url500List_;
+				std::vector<UrlList> url400List_;
+				std::string domainName_;
+				std::string startTime_;
+				std::vector<UrlList> url300List_;
+				std::vector<UrlList> allUrlList_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNDOMAINTOPURLVISITRESULT_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainTrafficDataRequest.h

@@ -89,8 +89,6 @@ namespace AlibabaCloud
 				void setRequestId(const std::string& requestId);
 				std::string getInterval()const;
 				void setInterval(const std::string& interval);
-				std::string getFields()const;
-				void setFields(const std::string& fields);
 
             private:
 				long callerParentId_;
@@ -120,7 +118,6 @@ namespace AlibabaCloud
 				bool security_transport_;
 				std::string requestId_;
 				std::string interval_;
-				std::string fields_;
 
 			};
 		}

scdn/include/alibabacloud/scdn/model/DescribeScdnTopDomainsByFlowRequest.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNTOPDOMAINSBYFLOWREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNTOPDOMAINSBYFLOWREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnTopDomainsByFlowRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnTopDomainsByFlowRequest();
+				~DescribeScdnTopDomainsByFlowRequest();
+
+				long getCallerParentId()const;
+				void setCallerParentId(long callerParentId);
+				bool getProxy_original_security_transport()const;
+				void setProxy_original_security_transport(bool proxy_original_security_transport);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getProxy_original_source_ip()const;
+				void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
+				std::string getOwnerIdLoginEmail()const;
+				void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
+				std::string getCallerType()const;
+				void setCallerType(const std::string& callerType);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRequestContent()const;
+				void setRequestContent(const std::string& requestContent);
+				long getLimit()const;
+				void setLimit(long limit);
+				std::string getCallerBidEmail()const;
+				void setCallerBidEmail(const std::string& callerBidEmail);
+				std::string getCallerUidEmail()const;
+				void setCallerUidEmail(const std::string& callerUidEmail);
+				long getCallerUid()const;
+				void setCallerUid(long callerUid);
+				std::string getApp_ip()const;
+				void setApp_ip(const std::string& app_ip);
+				std::string getPopProduct()const;
+				void setPopProduct(const std::string& popProduct);
+				std::string getProduct()const;
+				void setProduct(const std::string& product);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getCallerBid()const;
+				void setCallerBid(const std::string& callerBid);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getVersion()const;
+				void setVersion(const std::string& version);
+				bool getProxy_trust_transport_info()const;
+				void setProxy_trust_transport_info(bool proxy_trust_transport_info);
+				bool getAk_mfa_present()const;
+				void setAk_mfa_present(bool ak_mfa_present);
+				bool getSecurity_transport()const;
+				void setSecurity_transport(bool security_transport);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+
+            private:
+				long callerParentId_;
+				bool proxy_original_security_transport_;
+				std::string startTime_;
+				std::string proxy_original_source_ip_;
+				std::string ownerIdLoginEmail_;
+				std::string callerType_;
+				std::string accessKeyId_;
+				std::string securityToken_;
+				std::string requestContent_;
+				long limit_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string product_;
+				std::string endTime_;
+				std::string callerBid_;
+				long ownerId_;
+				std::string version_;
+				bool proxy_trust_transport_info_;
+				bool ak_mfa_present_;
+				bool security_transport_;
+				std::string requestId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNTOPDOMAINSBYFLOWREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnTopDomainsByFlowResult.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNTOPDOMAINSBYFLOWRESULT_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNTOPDOMAINSBYFLOWRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnTopDomainsByFlowResult : public ServiceResult
+			{
+			public:
+				struct TopDomain
+				{
+					long maxBps;
+					std::string domainName;
+					std::string maxBpsTime;
+					long rank;
+					std::string totalTraffic;
+					long totalAccess;
+					std::string trafficPercent;
+				};
+
+
+				DescribeScdnTopDomainsByFlowResult();
+				explicit DescribeScdnTopDomainsByFlowResult(const std::string &payload);
+				~DescribeScdnTopDomainsByFlowResult();
+				std::vector<TopDomain> getTopDomains()const;
+				std::string getEndTime()const;
+				long getDomainOnlineCount()const;
+				std::string getStartTime()const;
+				long getDomainCount()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<TopDomain> topDomains_;
+				std::string endTime_;
+				long domainOnlineCount_;
+				std::string startTime_;
+				long domainCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNTOPDOMAINSBYFLOWRESULT_H_

scdn/include/alibabacloud/scdn/model/OpenScdnServiceRequest.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_OPENSCDNSERVICEREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_OPENSCDNSERVICEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT OpenScdnServiceRequest : public RpcServiceRequest
+			{
+
+			public:
+				OpenScdnServiceRequest();
+				~OpenScdnServiceRequest();
+
+				std::string getEndDate()const;
+				void setEndDate(const std::string& endDate);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				int getBandwidth()const;
+				void setBandwidth(int bandwidth);
+				int getDomainCount()const;
+				void setDomainCount(int domainCount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getProtectType()const;
+				void setProtectType(const std::string& protectType);
+				std::string getStartDate()const;
+				void setStartDate(const std::string& startDate);
+				int getElasticProtection()const;
+				void setElasticProtection(int elasticProtection);
+				int getDDoSBasic()const;
+				void setDDoSBasic(int dDoSBasic);
+				int getCcProtection()const;
+				void setCcProtection(int ccProtection);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string endDate_;
+				std::string securityToken_;
+				int bandwidth_;
+				int domainCount_;
+				long ownerId_;
+				std::string protectType_;
+				std::string startDate_;
+				int elasticProtection_;
+				int dDoSBasic_;
+				int ccProtection_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_OPENSCDNSERVICEREQUEST_H_

scdn/include/alibabacloud/scdn/model/OpenScdnServiceResult.h

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

scdn/include/alibabacloud/scdn/model/SetDomainServerCertificateRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_SETDOMAINSERVERCERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_SETDOMAINSERVERCERTIFICATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT SetDomainServerCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				SetDomainServerCertificateRequest();
+				~SetDomainServerCertificateRequest();
+
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getSSLPub()const;
+				void setSSLPub(const std::string& sSLPub);
+				std::string getCertName()const;
+				void setCertName(const std::string& certName);
+				std::string getSSLProtocol()const;
+				void setSSLProtocol(const std::string& sSLProtocol);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getRegion()const;
+				void setRegion(const std::string& region);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSSLPri()const;
+				void setSSLPri(const std::string& sSLPri);
+
+            private:
+				std::string securityToken_;
+				std::string sSLPub_;
+				std::string certName_;
+				std::string sSLProtocol_;
+				std::string domainName_;
+				long ownerId_;
+				std::string region_;
+				std::string accessKeyId_;
+				std::string sSLPri_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_SETDOMAINSERVERCERTIFICATEREQUEST_H_

scdn/include/alibabacloud/scdn/model/SetDomainServerCertificateResult.h

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

scdn/include/alibabacloud/scdn/model/SetScdnDomainCertificateRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				SetScdnDomainCertificateRequest();
 				~SetScdnDomainCertificateRequest();
 
+				std::string getForceSet()const;
+				void setForceSet(const std::string& forceSet);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
 				std::string getCertType()const;
@@ -57,6 +59,7 @@ namespace AlibabaCloud
 				void setSSLPri(const std::string& sSLPri);
 
             private:
+				std::string forceSet_;
 				std::string securityToken_;
 				std::string certType_;
 				std::string sSLPub_;

scdn/src/ScdnClient.cc

@@ -87,6 +87,42 @@ ScdnClient::DescribeScdnRefreshQuotaOutcomeCallable ScdnClient::describeScdnRefr
 	return task->get_future();
 }
 
+ScdnClient::DescribeScdnDomainRealTimeByteHitRateDataOutcome ScdnClient::describeScdnDomainRealTimeByteHitRateData(const DescribeScdnDomainRealTimeByteHitRateDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainRealTimeByteHitRateDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainRealTimeByteHitRateDataOutcome(DescribeScdnDomainRealTimeByteHitRateDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainRealTimeByteHitRateDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainRealTimeByteHitRateDataAsync(const DescribeScdnDomainRealTimeByteHitRateDataRequest& request, const DescribeScdnDomainRealTimeByteHitRateDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainRealTimeByteHitRateData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainRealTimeByteHitRateDataOutcomeCallable ScdnClient::describeScdnDomainRealTimeByteHitRateDataCallable(const DescribeScdnDomainRealTimeByteHitRateDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainRealTimeByteHitRateDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainRealTimeByteHitRateData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::DescribeScdnDomainTrafficDataOutcome ScdnClient::describeScdnDomainTrafficData(const DescribeScdnDomainTrafficDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -159,6 +195,42 @@ ScdnClient::DescribeScdnDomainDetailOutcomeCallable ScdnClient::describeScdnDoma
 	return task->get_future();
 }
 
+ScdnClient::SetDomainServerCertificateOutcome ScdnClient::setDomainServerCertificate(const SetDomainServerCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetDomainServerCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetDomainServerCertificateOutcome(SetDomainServerCertificateResult(outcome.result()));
+	else
+		return SetDomainServerCertificateOutcome(outcome.error());
+}
+
+void ScdnClient::setDomainServerCertificateAsync(const SetDomainServerCertificateRequest& request, const SetDomainServerCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setDomainServerCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::SetDomainServerCertificateOutcomeCallable ScdnClient::setDomainServerCertificateCallable(const SetDomainServerCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetDomainServerCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->setDomainServerCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::DescribeScdnDomainOriginBpsDataOutcome ScdnClient::describeScdnDomainOriginBpsData(const DescribeScdnDomainOriginBpsDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +339,42 @@ ScdnClient::DescribeScdnDomainQpsDataOutcomeCallable ScdnClient::describeScdnDom
 	return task->get_future();
 }
 
+ScdnClient::DescribeScdnDomainTopReferVisitOutcome ScdnClient::describeScdnDomainTopReferVisit(const DescribeScdnDomainTopReferVisitRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainTopReferVisitOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainTopReferVisitOutcome(DescribeScdnDomainTopReferVisitResult(outcome.result()));
+	else
+		return DescribeScdnDomainTopReferVisitOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainTopReferVisitAsync(const DescribeScdnDomainTopReferVisitRequest& request, const DescribeScdnDomainTopReferVisitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainTopReferVisit(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainTopReferVisitOutcomeCallable ScdnClient::describeScdnDomainTopReferVisitCallable(const DescribeScdnDomainTopReferVisitRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainTopReferVisitOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainTopReferVisit(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::DescribeScdnDomainUvDataOutcome ScdnClient::describeScdnDomainUvData(const DescribeScdnDomainUvDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +411,42 @@ ScdnClient::DescribeScdnDomainUvDataOutcomeCallable ScdnClient::describeScdnDoma
 	return task->get_future();
 }
 
+ScdnClient::DescribeScdnDomainRegionDataOutcome ScdnClient::describeScdnDomainRegionData(const DescribeScdnDomainRegionDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainRegionDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainRegionDataOutcome(DescribeScdnDomainRegionDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainRegionDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainRegionDataAsync(const DescribeScdnDomainRegionDataRequest& request, const DescribeScdnDomainRegionDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainRegionData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainRegionDataOutcomeCallable ScdnClient::describeScdnDomainRegionDataCallable(const DescribeScdnDomainRegionDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainRegionDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainRegionData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::DescribeScdnIpInfoOutcome ScdnClient::describeScdnIpInfo(const DescribeScdnIpInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -375,6 +519,42 @@ ScdnClient::DescribeScdnDomainConfigsOutcomeCallable ScdnClient::describeScdnDom
 	return task->get_future();
 }
 
+ScdnClient::DescribeScdnDomainRealTimeBpsDataOutcome ScdnClient::describeScdnDomainRealTimeBpsData(const DescribeScdnDomainRealTimeBpsDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainRealTimeBpsDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainRealTimeBpsDataOutcome(DescribeScdnDomainRealTimeBpsDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainRealTimeBpsDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainRealTimeBpsDataAsync(const DescribeScdnDomainRealTimeBpsDataRequest& request, const DescribeScdnDomainRealTimeBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainRealTimeBpsData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainRealTimeBpsDataOutcomeCallable ScdnClient::describeScdnDomainRealTimeBpsDataCallable(const DescribeScdnDomainRealTimeBpsDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainRealTimeBpsDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainRealTimeBpsData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::SetScdnDomainCertificateOutcome ScdnClient::setScdnDomainCertificate(const SetScdnDomainCertificateRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -447,6 +627,78 @@ ScdnClient::BatchDeleteScdnDomainConfigsOutcomeCallable ScdnClient::batchDeleteS
 	return task->get_future();
 }
 
+ScdnClient::DescribeScdnDomainRealTimeSrcTrafficDataOutcome ScdnClient::describeScdnDomainRealTimeSrcTrafficData(const DescribeScdnDomainRealTimeSrcTrafficDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainRealTimeSrcTrafficDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainRealTimeSrcTrafficDataOutcome(DescribeScdnDomainRealTimeSrcTrafficDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainRealTimeSrcTrafficDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainRealTimeSrcTrafficDataAsync(const DescribeScdnDomainRealTimeSrcTrafficDataRequest& request, const DescribeScdnDomainRealTimeSrcTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainRealTimeSrcTrafficData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainRealTimeSrcTrafficDataOutcomeCallable ScdnClient::describeScdnDomainRealTimeSrcTrafficDataCallable(const DescribeScdnDomainRealTimeSrcTrafficDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainRealTimeSrcTrafficDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainRealTimeSrcTrafficData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnTopDomainsByFlowOutcome ScdnClient::describeScdnTopDomainsByFlow(const DescribeScdnTopDomainsByFlowRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnTopDomainsByFlowOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnTopDomainsByFlowOutcome(DescribeScdnTopDomainsByFlowResult(outcome.result()));
+	else
+		return DescribeScdnTopDomainsByFlowOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnTopDomainsByFlowAsync(const DescribeScdnTopDomainsByFlowRequest& request, const DescribeScdnTopDomainsByFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnTopDomainsByFlow(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnTopDomainsByFlowOutcomeCallable ScdnClient::describeScdnTopDomainsByFlowCallable(const DescribeScdnTopDomainsByFlowRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnTopDomainsByFlowOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnTopDomainsByFlow(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::DescribeScdnDomainBpsDataOutcome ScdnClient::describeScdnDomainBpsData(const DescribeScdnDomainBpsDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1023,6 +1275,78 @@ ScdnClient::RefreshScdnObjectCachesOutcomeCallable ScdnClient::refreshScdnObject
 	return task->get_future();
 }
 
+ScdnClient::DescribeScdnDomainRealTimeTrafficDataOutcome ScdnClient::describeScdnDomainRealTimeTrafficData(const DescribeScdnDomainRealTimeTrafficDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainRealTimeTrafficDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainRealTimeTrafficDataOutcome(DescribeScdnDomainRealTimeTrafficDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainRealTimeTrafficDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainRealTimeTrafficDataAsync(const DescribeScdnDomainRealTimeTrafficDataRequest& request, const DescribeScdnDomainRealTimeTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainRealTimeTrafficData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainRealTimeTrafficDataOutcomeCallable ScdnClient::describeScdnDomainRealTimeTrafficDataCallable(const DescribeScdnDomainRealTimeTrafficDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainRealTimeTrafficDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainRealTimeTrafficData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainRealTimeQpsDataOutcome ScdnClient::describeScdnDomainRealTimeQpsData(const DescribeScdnDomainRealTimeQpsDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainRealTimeQpsDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainRealTimeQpsDataOutcome(DescribeScdnDomainRealTimeQpsDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainRealTimeQpsDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainRealTimeQpsDataAsync(const DescribeScdnDomainRealTimeQpsDataRequest& request, const DescribeScdnDomainRealTimeQpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainRealTimeQpsData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainRealTimeQpsDataOutcomeCallable ScdnClient::describeScdnDomainRealTimeQpsDataCallable(const DescribeScdnDomainRealTimeQpsDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainRealTimeQpsDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainRealTimeQpsData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::DescribeScdnDomainCertificateInfoOutcome ScdnClient::describeScdnDomainCertificateInfo(const DescribeScdnDomainCertificateInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1059,6 +1383,42 @@ ScdnClient::DescribeScdnDomainCertificateInfoOutcomeCallable ScdnClient::describ
 	return task->get_future();
 }
 
+ScdnClient::DescribeScdnDomainRealTimeHttpCodeDataOutcome ScdnClient::describeScdnDomainRealTimeHttpCodeData(const DescribeScdnDomainRealTimeHttpCodeDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainRealTimeHttpCodeDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainRealTimeHttpCodeDataOutcome(DescribeScdnDomainRealTimeHttpCodeDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainRealTimeHttpCodeDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainRealTimeHttpCodeDataAsync(const DescribeScdnDomainRealTimeHttpCodeDataRequest& request, const DescribeScdnDomainRealTimeHttpCodeDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainRealTimeHttpCodeData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainRealTimeHttpCodeDataOutcomeCallable ScdnClient::describeScdnDomainRealTimeHttpCodeDataCallable(const DescribeScdnDomainRealTimeHttpCodeDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainRealTimeHttpCodeDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainRealTimeHttpCodeData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::CheckScdnServiceOutcome ScdnClient::checkScdnService(const CheckScdnServiceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1095,6 +1455,42 @@ ScdnClient::CheckScdnServiceOutcomeCallable ScdnClient::checkScdnServiceCallable
 	return task->get_future();
 }
 
+ScdnClient::BatchUpdateScdnDomainOutcome ScdnClient::batchUpdateScdnDomain(const BatchUpdateScdnDomainRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BatchUpdateScdnDomainOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BatchUpdateScdnDomainOutcome(BatchUpdateScdnDomainResult(outcome.result()));
+	else
+		return BatchUpdateScdnDomainOutcome(outcome.error());
+}
+
+void ScdnClient::batchUpdateScdnDomainAsync(const BatchUpdateScdnDomainRequest& request, const BatchUpdateScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, batchUpdateScdnDomain(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::BatchUpdateScdnDomainOutcomeCallable ScdnClient::batchUpdateScdnDomainCallable(const BatchUpdateScdnDomainRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BatchUpdateScdnDomainOutcome()>>(
+			[this, request]()
+			{
+			return this->batchUpdateScdnDomain(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::UpdateScdnDomainOutcome ScdnClient::updateScdnDomain(const UpdateScdnDomainRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1167,6 +1563,78 @@ ScdnClient::DescribeScdnDomainOriginTrafficDataOutcomeCallable ScdnClient::descr
 	return task->get_future();
 }
 
+ScdnClient::DescribeScdnDomainRealTimeReqHitRateDataOutcome ScdnClient::describeScdnDomainRealTimeReqHitRateData(const DescribeScdnDomainRealTimeReqHitRateDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainRealTimeReqHitRateDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainRealTimeReqHitRateDataOutcome(DescribeScdnDomainRealTimeReqHitRateDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainRealTimeReqHitRateDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainRealTimeReqHitRateDataAsync(const DescribeScdnDomainRealTimeReqHitRateDataRequest& request, const DescribeScdnDomainRealTimeReqHitRateDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainRealTimeReqHitRateData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainRealTimeReqHitRateDataOutcomeCallable ScdnClient::describeScdnDomainRealTimeReqHitRateDataCallable(const DescribeScdnDomainRealTimeReqHitRateDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainRealTimeReqHitRateDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainRealTimeReqHitRateData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainRealTimeSrcBpsDataOutcome ScdnClient::describeScdnDomainRealTimeSrcBpsData(const DescribeScdnDomainRealTimeSrcBpsDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainRealTimeSrcBpsDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainRealTimeSrcBpsDataOutcome(DescribeScdnDomainRealTimeSrcBpsDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainRealTimeSrcBpsDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainRealTimeSrcBpsDataAsync(const DescribeScdnDomainRealTimeSrcBpsDataRequest& request, const DescribeScdnDomainRealTimeSrcBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainRealTimeSrcBpsData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainRealTimeSrcBpsDataOutcomeCallable ScdnClient::describeScdnDomainRealTimeSrcBpsDataCallable(const DescribeScdnDomainRealTimeSrcBpsDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainRealTimeSrcBpsDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainRealTimeSrcBpsData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::DescribeScdnDomainIspDataOutcome ScdnClient::describeScdnDomainIspData(const DescribeScdnDomainIspDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,3 +1707,75 @@ ScdnClient::DescribeScdnRefreshTasksOutcomeCallable ScdnClient::describeScdnRefr
 	return task->get_future();
 }
 
+ScdnClient::OpenScdnServiceOutcome ScdnClient::openScdnService(const OpenScdnServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return OpenScdnServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return OpenScdnServiceOutcome(OpenScdnServiceResult(outcome.result()));
+	else
+		return OpenScdnServiceOutcome(outcome.error());
+}
+
+void ScdnClient::openScdnServiceAsync(const OpenScdnServiceRequest& request, const OpenScdnServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, openScdnService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::OpenScdnServiceOutcomeCallable ScdnClient::openScdnServiceCallable(const OpenScdnServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<OpenScdnServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->openScdnService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainTopUrlVisitOutcome ScdnClient::describeScdnDomainTopUrlVisit(const DescribeScdnDomainTopUrlVisitRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainTopUrlVisitOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainTopUrlVisitOutcome(DescribeScdnDomainTopUrlVisitResult(outcome.result()));
+	else
+		return DescribeScdnDomainTopUrlVisitOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainTopUrlVisitAsync(const DescribeScdnDomainTopUrlVisitRequest& request, const DescribeScdnDomainTopUrlVisitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainTopUrlVisit(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainTopUrlVisitOutcomeCallable ScdnClient::describeScdnDomainTopUrlVisitCallable(const DescribeScdnDomainTopUrlVisitRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainTopUrlVisitOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainTopUrlVisit(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

scdn/src/model/BatchUpdateScdnDomainRequest.cc

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/BatchUpdateScdnDomainRequest.h>
+
+using AlibabaCloud::Scdn::Model::BatchUpdateScdnDomainRequest;
+
+BatchUpdateScdnDomainRequest::BatchUpdateScdnDomainRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "BatchUpdateScdnDomain")
+{}
+
+BatchUpdateScdnDomainRequest::~BatchUpdateScdnDomainRequest()
+{}
+
+std::string BatchUpdateScdnDomainRequest::getTopLevelDomain()const
+{
+	return topLevelDomain_;
+}
+
+void BatchUpdateScdnDomainRequest::setTopLevelDomain(const std::string& topLevelDomain)
+{
+	topLevelDomain_ = topLevelDomain;
+	setParameter("TopLevelDomain", topLevelDomain);
+}
+
+std::string BatchUpdateScdnDomainRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void BatchUpdateScdnDomainRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
+std::string BatchUpdateScdnDomainRequest::getSources()const
+{
+	return sources_;
+}
+
+void BatchUpdateScdnDomainRequest::setSources(const std::string& sources)
+{
+	sources_ = sources;
+	setParameter("Sources", sources);
+}
+
+std::string BatchUpdateScdnDomainRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void BatchUpdateScdnDomainRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string BatchUpdateScdnDomainRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void BatchUpdateScdnDomainRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long BatchUpdateScdnDomainRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void BatchUpdateScdnDomainRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string BatchUpdateScdnDomainRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void BatchUpdateScdnDomainRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

scdn/src/model/BatchUpdateScdnDomainResult.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/BatchUpdateScdnDomainResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+BatchUpdateScdnDomainResult::BatchUpdateScdnDomainResult() :
+	ServiceResult()
+{}
+
+BatchUpdateScdnDomainResult::BatchUpdateScdnDomainResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+BatchUpdateScdnDomainResult::~BatchUpdateScdnDomainResult()
+{}
+
+void BatchUpdateScdnDomainResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

scdn/src/model/DescribeScdnDomainBpsDataRequest.cc

@@ -322,14 +322,3 @@ void DescribeScdnDomainBpsDataRequest::setInterval(const std::string& interval)
 	setParameter("Interval", interval);
 }
 
-std::string DescribeScdnDomainBpsDataRequest::getFields()const
-{
-	return fields_;
-}
-
-void DescribeScdnDomainBpsDataRequest::setFields(const std::string& fields)
-{
-	fields_ = fields;
-	setParameter("Fields", fields);
-}
-

scdn/src/model/DescribeScdnDomainHttpCodeDataRequest.cc

@@ -201,17 +201,6 @@ void DescribeScdnDomainHttpCodeDataRequest::setPopProduct(const std::string& pop
 	setParameter("PopProduct", popProduct);
 }
 
-std::string DescribeScdnDomainHttpCodeDataRequest::getProduct()const
-{
-	return product_;
-}
-
-void DescribeScdnDomainHttpCodeDataRequest::setProduct(const std::string& product)
-{
-	product_ = product;
-	setParameter("Product", product);
-}
-
 std::string DescribeScdnDomainHttpCodeDataRequest::getDomainName()const
 {
 	return domainName_;

scdn/src/model/DescribeScdnDomainIspDataResult.cc

@@ -40,12 +40,12 @@ void DescribeScdnDomainIspDataResult::parse(const std::string &payload)
 	reader.parse(payload, value);
 
 	setRequestId(value["RequestId"].asString());
-	auto allValue = value["Value"]["IspProportionData"];
+	auto allValue = value["Value"]["ISPProportionData"];
 	for (auto value : allValue)
 	{
-		IspProportionData valueObject;
-		if(!value["Isp"].isNull())
-			valueObject.isp = value["Isp"].asString();
+		ISPProportionData valueObject;
+		if(!value["ISP"].isNull())
+			valueObject.iSP = value["ISP"].asString();
 		if(!value["Proportion"].isNull())
 			valueObject.proportion = value["Proportion"].asString();
 		if(!value["IspEname"].isNull())
@@ -60,6 +60,8 @@ void DescribeScdnDomainIspDataResult::parse(const std::string &payload)
 			valueObject.qps = value["Qps"].asString();
 		if(!value["AvgResponseRate"].isNull())
 			valueObject.avgResponseRate = value["AvgResponseRate"].asString();
+		if(!value["ReqErrRate"].isNull())
+			valueObject.reqErrRate = value["ReqErrRate"].asString();
 		if(!value["TotalBytes"].isNull())
 			valueObject.totalBytes = value["TotalBytes"].asString();
 		if(!value["BytesProportion"].isNull())
@@ -89,7 +91,7 @@ std::string DescribeScdnDomainIspDataResult::getDomainName()const
 	return domainName_;
 }
 
-std::vector<DescribeScdnDomainIspDataResult::IspProportionData> DescribeScdnDomainIspDataResult::getValue()const
+std::vector<DescribeScdnDomainIspDataResult::ISPProportionData> DescribeScdnDomainIspDataResult::getValue()const
 {
 	return value_;
 }

scdn/src/model/DescribeScdnDomainQpsDataRequest.cc

@@ -322,14 +322,3 @@ void DescribeScdnDomainQpsDataRequest::setInterval(const std::string& interval)
 	setParameter("Interval", interval);
 }
 
-std::string DescribeScdnDomainQpsDataRequest::getFields()const
-{
-	return fields_;
-}
-
-void DescribeScdnDomainQpsDataRequest::setFields(const std::string& fields)
-{
-	fields_ = fields;
-	setParameter("Fields", fields);
-}
-

scdn/src/model/DescribeScdnDomainRealTimeBpsDataRequest.cc

@@ -0,0 +1,313 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeBpsDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainRealTimeBpsDataRequest;
+
+DescribeScdnDomainRealTimeBpsDataRequest::DescribeScdnDomainRealTimeBpsDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainRealTimeBpsData")
+{}
+
+DescribeScdnDomainRealTimeBpsDataRequest::~DescribeScdnDomainRealTimeBpsDataRequest()
+{}
+
+long DescribeScdnDomainRealTimeBpsDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainRealTimeBpsDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getLocationNameEn()const
+{
+	return locationNameEn_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setLocationNameEn(const std::string& locationNameEn)
+{
+	locationNameEn_ = locationNameEn;
+	setParameter("LocationNameEn", locationNameEn);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getIspNameEn()const
+{
+	return ispNameEn_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setIspNameEn(const std::string& ispNameEn)
+{
+	ispNameEn_ = ispNameEn;
+	setParameter("IspNameEn", ispNameEn);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainRealTimeBpsDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainRealTimeBpsDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainRealTimeBpsDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainRealTimeBpsDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainRealTimeBpsDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeBpsDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainRealTimeBpsDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+

scdn/src/model/DescribeScdnDomainRealTimeBpsDataResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeBpsDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainRealTimeBpsDataResult::DescribeScdnDomainRealTimeBpsDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainRealTimeBpsDataResult::DescribeScdnDomainRealTimeBpsDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainRealTimeBpsDataResult::~DescribeScdnDomainRealTimeBpsDataResult()
+{}
+
+void DescribeScdnDomainRealTimeBpsDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allData = value["Data"]["BpsModel"];
+	for (auto value : allData)
+	{
+		BpsModel dataObject;
+		if(!value["Bps"].isNull())
+			dataObject.bps = std::stof(value["Bps"].asString());
+		if(!value["TimeStamp"].isNull())
+			dataObject.timeStamp = value["TimeStamp"].asString();
+		data_.push_back(dataObject);
+	}
+
+}
+
+std::vector<DescribeScdnDomainRealTimeBpsDataResult::BpsModel> DescribeScdnDomainRealTimeBpsDataResult::getData()const
+{
+	return data_;
+}
+

scdn/src/model/DescribeScdnDomainRealTimeByteHitRateDataRequest.cc

@@ -0,0 +1,291 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeByteHitRateDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainRealTimeByteHitRateDataRequest;
+
+DescribeScdnDomainRealTimeByteHitRateDataRequest::DescribeScdnDomainRealTimeByteHitRateDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainRealTimeByteHitRateData")
+{}
+
+DescribeScdnDomainRealTimeByteHitRateDataRequest::~DescribeScdnDomainRealTimeByteHitRateDataRequest()
+{}
+
+long DescribeScdnDomainRealTimeByteHitRateDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainRealTimeByteHitRateDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainRealTimeByteHitRateDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainRealTimeByteHitRateDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainRealTimeByteHitRateDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainRealTimeByteHitRateDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainRealTimeByteHitRateDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainRealTimeByteHitRateDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+

scdn/src/model/DescribeScdnDomainRealTimeByteHitRateDataResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeByteHitRateDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainRealTimeByteHitRateDataResult::DescribeScdnDomainRealTimeByteHitRateDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainRealTimeByteHitRateDataResult::DescribeScdnDomainRealTimeByteHitRateDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainRealTimeByteHitRateDataResult::~DescribeScdnDomainRealTimeByteHitRateDataResult()
+{}
+
+void DescribeScdnDomainRealTimeByteHitRateDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allData = value["Data"]["ByteHitRateDataModel"];
+	for (auto value : allData)
+	{
+		ByteHitRateDataModel dataObject;
+		if(!value["ByteHitRate"].isNull())
+			dataObject.byteHitRate = std::stof(value["ByteHitRate"].asString());
+		if(!value["TimeStamp"].isNull())
+			dataObject.timeStamp = value["TimeStamp"].asString();
+		data_.push_back(dataObject);
+	}
+
+}
+
+std::vector<DescribeScdnDomainRealTimeByteHitRateDataResult::ByteHitRateDataModel> DescribeScdnDomainRealTimeByteHitRateDataResult::getData()const
+{
+	return data_;
+}
+

scdn/src/model/DescribeScdnDomainRealTimeHttpCodeDataRequest.cc

@@ -0,0 +1,335 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeHttpCodeDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainRealTimeHttpCodeDataRequest;
+
+DescribeScdnDomainRealTimeHttpCodeDataRequest::DescribeScdnDomainRealTimeHttpCodeDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainRealTimeHttpCodeData")
+{}
+
+DescribeScdnDomainRealTimeHttpCodeDataRequest::~DescribeScdnDomainRealTimeHttpCodeDataRequest()
+{}
+
+long DescribeScdnDomainRealTimeHttpCodeDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainRealTimeHttpCodeDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getLocationNameEn()const
+{
+	return locationNameEn_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setLocationNameEn(const std::string& locationNameEn)
+{
+	locationNameEn_ = locationNameEn;
+	setParameter("LocationNameEn", locationNameEn);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getIspNameEn()const
+{
+	return ispNameEn_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setIspNameEn(const std::string& ispNameEn)
+{
+	ispNameEn_ = ispNameEn;
+	setParameter("IspNameEn", ispNameEn);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainRealTimeHttpCodeDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainRealTimeHttpCodeDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainRealTimeHttpCodeDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainRealTimeHttpCodeDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainRealTimeHttpCodeDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getFields()const
+{
+	return fields_;
+}
+
+void DescribeScdnDomainRealTimeHttpCodeDataRequest::setFields(const std::string& fields)
+{
+	fields_ = fields;
+	setParameter("Fields", fields);
+}
+

scdn/src/model/DescribeScdnDomainRealTimeHttpCodeDataResult.cc

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeHttpCodeDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainRealTimeHttpCodeDataResult::DescribeScdnDomainRealTimeHttpCodeDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainRealTimeHttpCodeDataResult::DescribeScdnDomainRealTimeHttpCodeDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainRealTimeHttpCodeDataResult::~DescribeScdnDomainRealTimeHttpCodeDataResult()
+{}
+
+void DescribeScdnDomainRealTimeHttpCodeDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allRealTimeHttpCodeData = value["RealTimeHttpCodeData"]["UsageData"];
+	for (auto value : allRealTimeHttpCodeData)
+	{
+		UsageData realTimeHttpCodeDataObject;
+		if(!value["TimeStamp"].isNull())
+			realTimeHttpCodeDataObject.timeStamp = value["TimeStamp"].asString();
+		auto allValue = value["Value"]["RealTimeCodeProportionData"];
+		for (auto value : allValue)
+		{
+			UsageData::RealTimeCodeProportionData valueObject;
+			if(!value["Code"].isNull())
+				valueObject.code = value["Code"].asString();
+			if(!value["Proportion"].isNull())
+				valueObject.proportion = value["Proportion"].asString();
+			if(!value["Count"].isNull())
+				valueObject.count = value["Count"].asString();
+			realTimeHttpCodeDataObject.value.push_back(valueObject);
+		}
+		realTimeHttpCodeData_.push_back(realTimeHttpCodeDataObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::string DescribeScdnDomainRealTimeHttpCodeDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+
+std::vector<DescribeScdnDomainRealTimeHttpCodeDataResult::UsageData> DescribeScdnDomainRealTimeHttpCodeDataResult::getRealTimeHttpCodeData()const
+{
+	return realTimeHttpCodeData_;
+}
+

scdn/src/model/DescribeScdnDomainRealTimeQpsDataRequest.cc

@@ -0,0 +1,313 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeQpsDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainRealTimeQpsDataRequest;
+
+DescribeScdnDomainRealTimeQpsDataRequest::DescribeScdnDomainRealTimeQpsDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainRealTimeQpsData")
+{}
+
+DescribeScdnDomainRealTimeQpsDataRequest::~DescribeScdnDomainRealTimeQpsDataRequest()
+{}
+
+long DescribeScdnDomainRealTimeQpsDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainRealTimeQpsDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getLocationNameEn()const
+{
+	return locationNameEn_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setLocationNameEn(const std::string& locationNameEn)
+{
+	locationNameEn_ = locationNameEn;
+	setParameter("LocationNameEn", locationNameEn);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getIspNameEn()const
+{
+	return ispNameEn_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setIspNameEn(const std::string& ispNameEn)
+{
+	ispNameEn_ = ispNameEn;
+	setParameter("IspNameEn", ispNameEn);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainRealTimeQpsDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainRealTimeQpsDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainRealTimeQpsDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainRealTimeQpsDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainRealTimeQpsDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeQpsDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainRealTimeQpsDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+

scdn/src/model/DescribeScdnDomainRealTimeQpsDataResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeQpsDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainRealTimeQpsDataResult::DescribeScdnDomainRealTimeQpsDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainRealTimeQpsDataResult::DescribeScdnDomainRealTimeQpsDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainRealTimeQpsDataResult::~DescribeScdnDomainRealTimeQpsDataResult()
+{}
+
+void DescribeScdnDomainRealTimeQpsDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allData = value["Data"]["QpsModel"];
+	for (auto value : allData)
+	{
+		QpsModel dataObject;
+		if(!value["Qps"].isNull())
+			dataObject.qps = std::stof(value["Qps"].asString());
+		if(!value["TimeStamp"].isNull())
+			dataObject.timeStamp = value["TimeStamp"].asString();
+		data_.push_back(dataObject);
+	}
+
+}
+
+std::vector<DescribeScdnDomainRealTimeQpsDataResult::QpsModel> DescribeScdnDomainRealTimeQpsDataResult::getData()const
+{
+	return data_;
+}
+

scdn/src/model/DescribeScdnDomainRealTimeReqHitRateDataRequest.cc

@@ -0,0 +1,291 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeReqHitRateDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainRealTimeReqHitRateDataRequest;
+
+DescribeScdnDomainRealTimeReqHitRateDataRequest::DescribeScdnDomainRealTimeReqHitRateDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainRealTimeReqHitRateData")
+{}
+
+DescribeScdnDomainRealTimeReqHitRateDataRequest::~DescribeScdnDomainRealTimeReqHitRateDataRequest()
+{}
+
+long DescribeScdnDomainRealTimeReqHitRateDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainRealTimeReqHitRateDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainRealTimeReqHitRateDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainRealTimeReqHitRateDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainRealTimeReqHitRateDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainRealTimeReqHitRateDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainRealTimeReqHitRateDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainRealTimeReqHitRateDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+

scdn/src/model/DescribeScdnDomainRealTimeReqHitRateDataResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeReqHitRateDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainRealTimeReqHitRateDataResult::DescribeScdnDomainRealTimeReqHitRateDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainRealTimeReqHitRateDataResult::DescribeScdnDomainRealTimeReqHitRateDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainRealTimeReqHitRateDataResult::~DescribeScdnDomainRealTimeReqHitRateDataResult()
+{}
+
+void DescribeScdnDomainRealTimeReqHitRateDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allData = value["Data"]["ReqHitRateDataModel"];
+	for (auto value : allData)
+	{
+		ReqHitRateDataModel dataObject;
+		if(!value["ReqHitRate"].isNull())
+			dataObject.reqHitRate = std::stof(value["ReqHitRate"].asString());
+		if(!value["TimeStamp"].isNull())
+			dataObject.timeStamp = value["TimeStamp"].asString();
+		data_.push_back(dataObject);
+	}
+
+}
+
+std::vector<DescribeScdnDomainRealTimeReqHitRateDataResult::ReqHitRateDataModel> DescribeScdnDomainRealTimeReqHitRateDataResult::getData()const
+{
+	return data_;
+}
+

scdn/src/model/DescribeScdnDomainRealTimeSrcBpsDataRequest.cc

@@ -0,0 +1,313 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcBpsDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainRealTimeSrcBpsDataRequest;
+
+DescribeScdnDomainRealTimeSrcBpsDataRequest::DescribeScdnDomainRealTimeSrcBpsDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainRealTimeSrcBpsData")
+{}
+
+DescribeScdnDomainRealTimeSrcBpsDataRequest::~DescribeScdnDomainRealTimeSrcBpsDataRequest()
+{}
+
+long DescribeScdnDomainRealTimeSrcBpsDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainRealTimeSrcBpsDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainRealTimeSrcBpsDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainRealTimeSrcBpsDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainRealTimeSrcBpsDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainRealTimeSrcBpsDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainRealTimeSrcBpsDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getFields()const
+{
+	return fields_;
+}
+
+void DescribeScdnDomainRealTimeSrcBpsDataRequest::setFields(const std::string& fields)
+{
+	fields_ = fields;
+	setParameter("Fields", fields);
+}
+

scdn/src/model/DescribeScdnDomainRealTimeSrcBpsDataResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcBpsDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainRealTimeSrcBpsDataResult::DescribeScdnDomainRealTimeSrcBpsDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainRealTimeSrcBpsDataResult::DescribeScdnDomainRealTimeSrcBpsDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainRealTimeSrcBpsDataResult::~DescribeScdnDomainRealTimeSrcBpsDataResult()
+{}
+
+void DescribeScdnDomainRealTimeSrcBpsDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allRealTimeSrcBpsDataPerInterval = value["RealTimeSrcBpsDataPerInterval"]["DataModule"];
+	for (auto value : allRealTimeSrcBpsDataPerInterval)
+	{
+		DataModule realTimeSrcBpsDataPerIntervalObject;
+		if(!value["TimeStamp"].isNull())
+			realTimeSrcBpsDataPerIntervalObject.timeStamp = value["TimeStamp"].asString();
+		if(!value["Value"].isNull())
+			realTimeSrcBpsDataPerIntervalObject.value = value["Value"].asString();
+		realTimeSrcBpsDataPerInterval_.push_back(realTimeSrcBpsDataPerIntervalObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::vector<DescribeScdnDomainRealTimeSrcBpsDataResult::DataModule> DescribeScdnDomainRealTimeSrcBpsDataResult::getRealTimeSrcBpsDataPerInterval()const
+{
+	return realTimeSrcBpsDataPerInterval_;
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::string DescribeScdnDomainRealTimeSrcBpsDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+

scdn/src/model/DescribeScdnDomainRealTimeSrcTrafficDataRequest.cc

@@ -0,0 +1,313 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcTrafficDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainRealTimeSrcTrafficDataRequest;
+
+DescribeScdnDomainRealTimeSrcTrafficDataRequest::DescribeScdnDomainRealTimeSrcTrafficDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainRealTimeSrcTrafficData")
+{}
+
+DescribeScdnDomainRealTimeSrcTrafficDataRequest::~DescribeScdnDomainRealTimeSrcTrafficDataRequest()
+{}
+
+long DescribeScdnDomainRealTimeSrcTrafficDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainRealTimeSrcTrafficDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainRealTimeSrcTrafficDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainRealTimeSrcTrafficDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainRealTimeSrcTrafficDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainRealTimeSrcTrafficDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainRealTimeSrcTrafficDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getFields()const
+{
+	return fields_;
+}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setFields(const std::string& fields)
+{
+	fields_ = fields;
+	setParameter("Fields", fields);
+}
+

scdn/src/model/DescribeScdnDomainRealTimeSrcTrafficDataResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeSrcTrafficDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainRealTimeSrcTrafficDataResult::DescribeScdnDomainRealTimeSrcTrafficDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainRealTimeSrcTrafficDataResult::DescribeScdnDomainRealTimeSrcTrafficDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainRealTimeSrcTrafficDataResult::~DescribeScdnDomainRealTimeSrcTrafficDataResult()
+{}
+
+void DescribeScdnDomainRealTimeSrcTrafficDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allRealTimeSrcTrafficDataPerInterval = value["RealTimeSrcTrafficDataPerInterval"]["DataModule"];
+	for (auto value : allRealTimeSrcTrafficDataPerInterval)
+	{
+		DataModule realTimeSrcTrafficDataPerIntervalObject;
+		if(!value["TimeStamp"].isNull())
+			realTimeSrcTrafficDataPerIntervalObject.timeStamp = value["TimeStamp"].asString();
+		if(!value["Value"].isNull())
+			realTimeSrcTrafficDataPerIntervalObject.value = value["Value"].asString();
+		realTimeSrcTrafficDataPerInterval_.push_back(realTimeSrcTrafficDataPerIntervalObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::string DescribeScdnDomainRealTimeSrcTrafficDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+
+std::vector<DescribeScdnDomainRealTimeSrcTrafficDataResult::DataModule> DescribeScdnDomainRealTimeSrcTrafficDataResult::getRealTimeSrcTrafficDataPerInterval()const
+{
+	return realTimeSrcTrafficDataPerInterval_;
+}
+

scdn/src/model/DescribeScdnDomainRealTimeTrafficDataRequest.cc

@@ -0,0 +1,313 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeTrafficDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainRealTimeTrafficDataRequest;
+
+DescribeScdnDomainRealTimeTrafficDataRequest::DescribeScdnDomainRealTimeTrafficDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainRealTimeTrafficData")
+{}
+
+DescribeScdnDomainRealTimeTrafficDataRequest::~DescribeScdnDomainRealTimeTrafficDataRequest()
+{}
+
+long DescribeScdnDomainRealTimeTrafficDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainRealTimeTrafficDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainRealTimeTrafficDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainRealTimeTrafficDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainRealTimeTrafficDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainRealTimeTrafficDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainRealTimeTrafficDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataRequest::getFields()const
+{
+	return fields_;
+}
+
+void DescribeScdnDomainRealTimeTrafficDataRequest::setFields(const std::string& fields)
+{
+	fields_ = fields;
+	setParameter("Fields", fields);
+}
+

scdn/src/model/DescribeScdnDomainRealTimeTrafficDataResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRealTimeTrafficDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainRealTimeTrafficDataResult::DescribeScdnDomainRealTimeTrafficDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainRealTimeTrafficDataResult::DescribeScdnDomainRealTimeTrafficDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainRealTimeTrafficDataResult::~DescribeScdnDomainRealTimeTrafficDataResult()
+{}
+
+void DescribeScdnDomainRealTimeTrafficDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allRealTimeTrafficDataPerInterval = value["RealTimeTrafficDataPerInterval"]["DataModule"];
+	for (auto value : allRealTimeTrafficDataPerInterval)
+	{
+		DataModule realTimeTrafficDataPerIntervalObject;
+		if(!value["TimeStamp"].isNull())
+			realTimeTrafficDataPerIntervalObject.timeStamp = value["TimeStamp"].asString();
+		if(!value["Value"].isNull())
+			realTimeTrafficDataPerIntervalObject.value = value["Value"].asString();
+		realTimeTrafficDataPerInterval_.push_back(realTimeTrafficDataPerIntervalObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::vector<DescribeScdnDomainRealTimeTrafficDataResult::DataModule> DescribeScdnDomainRealTimeTrafficDataResult::getRealTimeTrafficDataPerInterval()const
+{
+	return realTimeTrafficDataPerInterval_;
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::string DescribeScdnDomainRealTimeTrafficDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+

scdn/src/model/DescribeScdnDomainRegionDataRequest.cc

@@ -0,0 +1,291 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRegionDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainRegionDataRequest;
+
+DescribeScdnDomainRegionDataRequest::DescribeScdnDomainRegionDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainRegionData")
+{}
+
+DescribeScdnDomainRegionDataRequest::~DescribeScdnDomainRegionDataRequest()
+{}
+
+long DescribeScdnDomainRegionDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainRegionDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainRegionDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainRegionDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainRegionDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainRegionDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainRegionDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainRegionDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainRegionDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+

scdn/src/model/DescribeScdnDomainRegionDataResult.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainRegionDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainRegionDataResult::DescribeScdnDomainRegionDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainRegionDataResult::DescribeScdnDomainRegionDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainRegionDataResult::~DescribeScdnDomainRegionDataResult()
+{}
+
+void DescribeScdnDomainRegionDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allValue = value["Value"]["RegionProportionData"];
+	for (auto value : allValue)
+	{
+		RegionProportionData valueObject;
+		if(!value["Region"].isNull())
+			valueObject.region = value["Region"].asString();
+		if(!value["Proportion"].isNull())
+			valueObject.proportion = value["Proportion"].asString();
+		if(!value["RegionEname"].isNull())
+			valueObject.regionEname = value["RegionEname"].asString();
+		if(!value["AvgObjectSize"].isNull())
+			valueObject.avgObjectSize = value["AvgObjectSize"].asString();
+		if(!value["AvgResponseTime"].isNull())
+			valueObject.avgResponseTime = value["AvgResponseTime"].asString();
+		if(!value["Bps"].isNull())
+			valueObject.bps = value["Bps"].asString();
+		if(!value["Qps"].isNull())
+			valueObject.qps = value["Qps"].asString();
+		if(!value["AvgResponseRate"].isNull())
+			valueObject.avgResponseRate = value["AvgResponseRate"].asString();
+		if(!value["ReqErrRate"].isNull())
+			valueObject.reqErrRate = value["ReqErrRate"].asString();
+		if(!value["TotalBytes"].isNull())
+			valueObject.totalBytes = value["TotalBytes"].asString();
+		if(!value["BytesProportion"].isNull())
+			valueObject.bytesProportion = value["BytesProportion"].asString();
+		if(!value["TotalQuery"].isNull())
+			valueObject.totalQuery = value["TotalQuery"].asString();
+		value_.push_back(valueObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+
+}
+
+std::string DescribeScdnDomainRegionDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeScdnDomainRegionDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::vector<DescribeScdnDomainRegionDataResult::RegionProportionData> DescribeScdnDomainRegionDataResult::getValue()const
+{
+	return value_;
+}
+
+std::string DescribeScdnDomainRegionDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+
+std::string DescribeScdnDomainRegionDataResult::getStartTime()const
+{
+	return startTime_;
+}
+

scdn/src/model/DescribeScdnDomainTopReferVisitRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainTopReferVisitRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainTopReferVisitRequest;
+
+DescribeScdnDomainTopReferVisitRequest::DescribeScdnDomainTopReferVisitRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainTopReferVisit")
+{}
+
+DescribeScdnDomainTopReferVisitRequest::~DescribeScdnDomainTopReferVisitRequest()
+{}
+
+std::string DescribeScdnDomainTopReferVisitRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainTopReferVisitRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainTopReferVisitRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainTopReferVisitRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainTopReferVisitRequest::getSortBy()const
+{
+	return sortBy_;
+}
+
+void DescribeScdnDomainTopReferVisitRequest::setSortBy(const std::string& sortBy)
+{
+	sortBy_ = sortBy;
+	setParameter("SortBy", sortBy);
+}
+
+std::string DescribeScdnDomainTopReferVisitRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainTopReferVisitRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+long DescribeScdnDomainTopReferVisitRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainTopReferVisitRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainTopReferVisitRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainTopReferVisitRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

scdn/src/model/DescribeScdnDomainTopReferVisitResult.cc

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainTopReferVisitResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainTopReferVisitResult::DescribeScdnDomainTopReferVisitResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainTopReferVisitResult::DescribeScdnDomainTopReferVisitResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainTopReferVisitResult::~DescribeScdnDomainTopReferVisitResult()
+{}
+
+void DescribeScdnDomainTopReferVisitResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allTopReferList = value["TopReferList"]["ReferList"];
+	for (auto value : allTopReferList)
+	{
+		ReferList topReferListObject;
+		if(!value["ReferDetail"].isNull())
+			topReferListObject.referDetail = value["ReferDetail"].asString();
+		if(!value["VisitData"].isNull())
+			topReferListObject.visitData = value["VisitData"].asString();
+		if(!value["VisitProportion"].isNull())
+			topReferListObject.visitProportion = std::stof(value["VisitProportion"].asString());
+		if(!value["Flow"].isNull())
+			topReferListObject.flow = value["Flow"].asString();
+		if(!value["FlowProportion"].isNull())
+			topReferListObject.flowProportion = std::stof(value["FlowProportion"].asString());
+		topReferList_.push_back(topReferListObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+
+}
+
+std::string DescribeScdnDomainTopReferVisitResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeScdnDomainTopReferVisitResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::vector<DescribeScdnDomainTopReferVisitResult::ReferList> DescribeScdnDomainTopReferVisitResult::getTopReferList()const
+{
+	return topReferList_;
+}
+

scdn/src/model/DescribeScdnDomainTopUrlVisitRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainTopUrlVisitRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainTopUrlVisitRequest;
+
+DescribeScdnDomainTopUrlVisitRequest::DescribeScdnDomainTopUrlVisitRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainTopUrlVisit")
+{}
+
+DescribeScdnDomainTopUrlVisitRequest::~DescribeScdnDomainTopUrlVisitRequest()
+{}
+
+std::string DescribeScdnDomainTopUrlVisitRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainTopUrlVisitRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainTopUrlVisitRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainTopUrlVisitRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainTopUrlVisitRequest::getSortBy()const
+{
+	return sortBy_;
+}
+
+void DescribeScdnDomainTopUrlVisitRequest::setSortBy(const std::string& sortBy)
+{
+	sortBy_ = sortBy;
+	setParameter("SortBy", sortBy);
+}
+
+std::string DescribeScdnDomainTopUrlVisitRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainTopUrlVisitRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+long DescribeScdnDomainTopUrlVisitRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainTopUrlVisitRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainTopUrlVisitRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainTopUrlVisitRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

scdn/src/model/DescribeScdnDomainTopUrlVisitResult.cc

@@ -0,0 +1,164 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainTopUrlVisitResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainTopUrlVisitResult::DescribeScdnDomainTopUrlVisitResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainTopUrlVisitResult::DescribeScdnDomainTopUrlVisitResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainTopUrlVisitResult::~DescribeScdnDomainTopUrlVisitResult()
+{}
+
+void DescribeScdnDomainTopUrlVisitResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allAllUrlList = value["AllUrlList"]["UrlList"];
+	for (auto value : allAllUrlList)
+	{
+		UrlList allUrlListObject;
+		if(!value["UrlDetail"].isNull())
+			allUrlListObject.urlDetail = value["UrlDetail"].asString();
+		if(!value["VisitData"].isNull())
+			allUrlListObject.visitData = value["VisitData"].asString();
+		if(!value["VisitProportion"].isNull())
+			allUrlListObject.visitProportion = std::stof(value["VisitProportion"].asString());
+		if(!value["Flow"].isNull())
+			allUrlListObject.flow = value["Flow"].asString();
+		if(!value["FlowProportion"].isNull())
+			allUrlListObject.flowProportion = std::stof(value["FlowProportion"].asString());
+		allUrlList_.push_back(allUrlListObject);
+	}
+	auto allUrl200List = value["Url200List"]["UrlList"];
+	for (auto value : allUrl200List)
+	{
+		UrlList url200ListObject;
+		if(!value["UrlDetail"].isNull())
+			url200ListObject.urlDetail = value["UrlDetail"].asString();
+		if(!value["VisitData"].isNull())
+			url200ListObject.visitData = value["VisitData"].asString();
+		if(!value["VisitProportion"].isNull())
+			url200ListObject.visitProportion = std::stof(value["VisitProportion"].asString());
+		if(!value["Flow"].isNull())
+			url200ListObject.flow = value["Flow"].asString();
+		if(!value["FlowProportion"].isNull())
+			url200ListObject.flowProportion = std::stof(value["FlowProportion"].asString());
+		url200List_.push_back(url200ListObject);
+	}
+	auto allUrl300List = value["Url300List"]["UrlList"];
+	for (auto value : allUrl300List)
+	{
+		UrlList url300ListObject;
+		if(!value["UrlDetail"].isNull())
+			url300ListObject.urlDetail = value["UrlDetail"].asString();
+		if(!value["VisitData"].isNull())
+			url300ListObject.visitData = value["VisitData"].asString();
+		if(!value["VisitProportion"].isNull())
+			url300ListObject.visitProportion = std::stof(value["VisitProportion"].asString());
+		if(!value["Flow"].isNull())
+			url300ListObject.flow = value["Flow"].asString();
+		if(!value["FlowProportion"].isNull())
+			url300ListObject.flowProportion = std::stof(value["FlowProportion"].asString());
+		url300List_.push_back(url300ListObject);
+	}
+	auto allUrl400List = value["Url400List"]["UrlList"];
+	for (auto value : allUrl400List)
+	{
+		UrlList url400ListObject;
+		if(!value["UrlDetail"].isNull())
+			url400ListObject.urlDetail = value["UrlDetail"].asString();
+		if(!value["VisitData"].isNull())
+			url400ListObject.visitData = value["VisitData"].asString();
+		if(!value["VisitProportion"].isNull())
+			url400ListObject.visitProportion = std::stof(value["VisitProportion"].asString());
+		if(!value["Flow"].isNull())
+			url400ListObject.flow = value["Flow"].asString();
+		if(!value["FlowProportion"].isNull())
+			url400ListObject.flowProportion = std::stof(value["FlowProportion"].asString());
+		url400List_.push_back(url400ListObject);
+	}
+	auto allUrl500List = value["Url500List"]["UrlList"];
+	for (auto value : allUrl500List)
+	{
+		UrlList url500ListObject;
+		if(!value["UrlDetail"].isNull())
+			url500ListObject.urlDetail = value["UrlDetail"].asString();
+		if(!value["VisitData"].isNull())
+			url500ListObject.visitData = value["VisitData"].asString();
+		if(!value["VisitProportion"].isNull())
+			url500ListObject.visitProportion = std::stof(value["VisitProportion"].asString());
+		if(!value["Flow"].isNull())
+			url500ListObject.flow = value["Flow"].asString();
+		if(!value["FlowProportion"].isNull())
+			url500ListObject.flowProportion = std::stof(value["FlowProportion"].asString());
+		url500List_.push_back(url500ListObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+
+}
+
+std::vector<DescribeScdnDomainTopUrlVisitResult::UrlList> DescribeScdnDomainTopUrlVisitResult::getUrl200List()const
+{
+	return url200List_;
+}
+
+std::vector<DescribeScdnDomainTopUrlVisitResult::UrlList> DescribeScdnDomainTopUrlVisitResult::getUrl500List()const
+{
+	return url500List_;
+}
+
+std::vector<DescribeScdnDomainTopUrlVisitResult::UrlList> DescribeScdnDomainTopUrlVisitResult::getUrl400List()const
+{
+	return url400List_;
+}
+
+std::string DescribeScdnDomainTopUrlVisitResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeScdnDomainTopUrlVisitResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::vector<DescribeScdnDomainTopUrlVisitResult::UrlList> DescribeScdnDomainTopUrlVisitResult::getUrl300List()const
+{
+	return url300List_;
+}
+
+std::vector<DescribeScdnDomainTopUrlVisitResult::UrlList> DescribeScdnDomainTopUrlVisitResult::getAllUrlList()const
+{
+	return allUrlList_;
+}
+

scdn/src/model/DescribeScdnDomainTrafficDataRequest.cc

@@ -322,14 +322,3 @@ void DescribeScdnDomainTrafficDataRequest::setInterval(const std::string& interv
 	setParameter("Interval", interval);
 }
 
-std::string DescribeScdnDomainTrafficDataRequest::getFields()const
-{
-	return fields_;
-}
-
-void DescribeScdnDomainTrafficDataRequest::setFields(const std::string& fields)
-{
-	fields_ = fields;
-	setParameter("Fields", fields);
-}
-

scdn/src/model/DescribeScdnTopDomainsByFlowRequest.cc

@@ -0,0 +1,291 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnTopDomainsByFlowRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnTopDomainsByFlowRequest;
+
+DescribeScdnTopDomainsByFlowRequest::DescribeScdnTopDomainsByFlowRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnTopDomainsByFlow")
+{}
+
+DescribeScdnTopDomainsByFlowRequest::~DescribeScdnTopDomainsByFlowRequest()
+{}
+
+long DescribeScdnTopDomainsByFlowRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnTopDomainsByFlowRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+long DescribeScdnTopDomainsByFlowRequest::getLimit()const
+{
+	return limit_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setLimit(long limit)
+{
+	limit_ = limit;
+	setParameter("Limit", std::to_string(limit));
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnTopDomainsByFlowRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnTopDomainsByFlowRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnTopDomainsByFlowRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnTopDomainsByFlowRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnTopDomainsByFlowRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnTopDomainsByFlowRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnTopDomainsByFlowRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+

scdn/src/model/DescribeScdnTopDomainsByFlowResult.cc

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnTopDomainsByFlowResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnTopDomainsByFlowResult::DescribeScdnTopDomainsByFlowResult() :
+	ServiceResult()
+{}
+
+DescribeScdnTopDomainsByFlowResult::DescribeScdnTopDomainsByFlowResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnTopDomainsByFlowResult::~DescribeScdnTopDomainsByFlowResult()
+{}
+
+void DescribeScdnTopDomainsByFlowResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allTopDomains = value["TopDomains"]["TopDomain"];
+	for (auto value : allTopDomains)
+	{
+		TopDomain topDomainsObject;
+		if(!value["DomainName"].isNull())
+			topDomainsObject.domainName = value["DomainName"].asString();
+		if(!value["Rank"].isNull())
+			topDomainsObject.rank = std::stol(value["Rank"].asString());
+		if(!value["TotalTraffic"].isNull())
+			topDomainsObject.totalTraffic = value["TotalTraffic"].asString();
+		if(!value["TrafficPercent"].isNull())
+			topDomainsObject.trafficPercent = value["TrafficPercent"].asString();
+		if(!value["MaxBps"].isNull())
+			topDomainsObject.maxBps = std::stol(value["MaxBps"].asString());
+		if(!value["MaxBpsTime"].isNull())
+			topDomainsObject.maxBpsTime = value["MaxBpsTime"].asString();
+		if(!value["TotalAccess"].isNull())
+			topDomainsObject.totalAccess = std::stol(value["TotalAccess"].asString());
+		topDomains_.push_back(topDomainsObject);
+	}
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["DomainCount"].isNull())
+		domainCount_ = std::stol(value["DomainCount"].asString());
+	if(!value["DomainOnlineCount"].isNull())
+		domainOnlineCount_ = std::stol(value["DomainOnlineCount"].asString());
+
+}
+
+std::vector<DescribeScdnTopDomainsByFlowResult::TopDomain> DescribeScdnTopDomainsByFlowResult::getTopDomains()const
+{
+	return topDomains_;
+}
+
+std::string DescribeScdnTopDomainsByFlowResult::getEndTime()const
+{
+	return endTime_;
+}
+
+long DescribeScdnTopDomainsByFlowResult::getDomainOnlineCount()const
+{
+	return domainOnlineCount_;
+}
+
+std::string DescribeScdnTopDomainsByFlowResult::getStartTime()const
+{
+	return startTime_;
+}
+
+long DescribeScdnTopDomainsByFlowResult::getDomainCount()const
+{
+	return domainCount_;
+}
+

scdn/src/model/OpenScdnServiceRequest.cc

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/OpenScdnServiceRequest.h>
+
+using AlibabaCloud::Scdn::Model::OpenScdnServiceRequest;
+
+OpenScdnServiceRequest::OpenScdnServiceRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "OpenScdnService")
+{}
+
+OpenScdnServiceRequest::~OpenScdnServiceRequest()
+{}
+
+std::string OpenScdnServiceRequest::getEndDate()const
+{
+	return endDate_;
+}
+
+void OpenScdnServiceRequest::setEndDate(const std::string& endDate)
+{
+	endDate_ = endDate;
+	setParameter("EndDate", endDate);
+}
+
+std::string OpenScdnServiceRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void OpenScdnServiceRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+int OpenScdnServiceRequest::getBandwidth()const
+{
+	return bandwidth_;
+}
+
+void OpenScdnServiceRequest::setBandwidth(int bandwidth)
+{
+	bandwidth_ = bandwidth;
+	setParameter("Bandwidth", std::to_string(bandwidth));
+}
+
+int OpenScdnServiceRequest::getDomainCount()const
+{
+	return domainCount_;
+}
+
+void OpenScdnServiceRequest::setDomainCount(int domainCount)
+{
+	domainCount_ = domainCount;
+	setParameter("DomainCount", std::to_string(domainCount));
+}
+
+long OpenScdnServiceRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void OpenScdnServiceRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string OpenScdnServiceRequest::getProtectType()const
+{
+	return protectType_;
+}
+
+void OpenScdnServiceRequest::setProtectType(const std::string& protectType)
+{
+	protectType_ = protectType;
+	setParameter("ProtectType", protectType);
+}
+
+std::string OpenScdnServiceRequest::getStartDate()const
+{
+	return startDate_;
+}
+
+void OpenScdnServiceRequest::setStartDate(const std::string& startDate)
+{
+	startDate_ = startDate;
+	setParameter("StartDate", startDate);
+}
+
+int OpenScdnServiceRequest::getElasticProtection()const
+{
+	return elasticProtection_;
+}
+
+void OpenScdnServiceRequest::setElasticProtection(int elasticProtection)
+{
+	elasticProtection_ = elasticProtection;
+	setParameter("ElasticProtection", std::to_string(elasticProtection));
+}
+
+int OpenScdnServiceRequest::getDDoSBasic()const
+{
+	return dDoSBasic_;
+}
+
+void OpenScdnServiceRequest::setDDoSBasic(int dDoSBasic)
+{
+	dDoSBasic_ = dDoSBasic;
+	setParameter("DDoSBasic", std::to_string(dDoSBasic));
+}
+
+int OpenScdnServiceRequest::getCcProtection()const
+{
+	return ccProtection_;
+}
+
+void OpenScdnServiceRequest::setCcProtection(int ccProtection)
+{
+	ccProtection_ = ccProtection;
+	setParameter("CcProtection", std::to_string(ccProtection));
+}
+
+std::string OpenScdnServiceRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void OpenScdnServiceRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

scdn/src/model/OpenScdnServiceResult.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/OpenScdnServiceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+OpenScdnServiceResult::OpenScdnServiceResult() :
+	ServiceResult()
+{}
+
+OpenScdnServiceResult::OpenScdnServiceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+OpenScdnServiceResult::~OpenScdnServiceResult()
+{}
+
+void OpenScdnServiceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

scdn/src/model/SetDomainServerCertificateRequest.cc

@@ -0,0 +1,126 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/SetDomainServerCertificateRequest.h>
+
+using AlibabaCloud::Scdn::Model::SetDomainServerCertificateRequest;
+
+SetDomainServerCertificateRequest::SetDomainServerCertificateRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "SetDomainServerCertificate")
+{}
+
+SetDomainServerCertificateRequest::~SetDomainServerCertificateRequest()
+{}
+
+std::string SetDomainServerCertificateRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void SetDomainServerCertificateRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string SetDomainServerCertificateRequest::getSSLPub()const
+{
+	return sSLPub_;
+}
+
+void SetDomainServerCertificateRequest::setSSLPub(const std::string& sSLPub)
+{
+	sSLPub_ = sSLPub;
+	setParameter("SSLPub", sSLPub);
+}
+
+std::string SetDomainServerCertificateRequest::getCertName()const
+{
+	return certName_;
+}
+
+void SetDomainServerCertificateRequest::setCertName(const std::string& certName)
+{
+	certName_ = certName;
+	setParameter("CertName", certName);
+}
+
+std::string SetDomainServerCertificateRequest::getSSLProtocol()const
+{
+	return sSLProtocol_;
+}
+
+void SetDomainServerCertificateRequest::setSSLProtocol(const std::string& sSLProtocol)
+{
+	sSLProtocol_ = sSLProtocol;
+	setParameter("SSLProtocol", sSLProtocol);
+}
+
+std::string SetDomainServerCertificateRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void SetDomainServerCertificateRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long SetDomainServerCertificateRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetDomainServerCertificateRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SetDomainServerCertificateRequest::getRegion()const
+{
+	return region_;
+}
+
+void SetDomainServerCertificateRequest::setRegion(const std::string& region)
+{
+	region_ = region;
+	setParameter("Region", region);
+}
+
+std::string SetDomainServerCertificateRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void SetDomainServerCertificateRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string SetDomainServerCertificateRequest::getSSLPri()const
+{
+	return sSLPri_;
+}
+
+void SetDomainServerCertificateRequest::setSSLPri(const std::string& sSLPri)
+{
+	sSLPri_ = sSLPri;
+	setParameter("SSLPri", sSLPri);
+}
+

scdn/src/model/SetDomainServerCertificateResult.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/SetDomainServerCertificateResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+SetDomainServerCertificateResult::SetDomainServerCertificateResult() :
+	ServiceResult()
+{}
+
+SetDomainServerCertificateResult::SetDomainServerCertificateResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetDomainServerCertificateResult::~SetDomainServerCertificateResult()
+{}
+
+void SetDomainServerCertificateResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+
+}
+

scdn/src/model/SetScdnDomainCertificateRequest.cc

@@ -25,6 +25,17 @@ SetScdnDomainCertificateRequest::SetScdnDomainCertificateRequest() :
 SetScdnDomainCertificateRequest::~SetScdnDomainCertificateRequest()
 {}
 
+std::string SetScdnDomainCertificateRequest::getForceSet()const
+{
+	return forceSet_;
+}
+
+void SetScdnDomainCertificateRequest::setForceSet(const std::string& forceSet)
+{
+	forceSet_ = forceSet;
+	setParameter("ForceSet", forceSet);
+}
+
 std::string SetScdnDomainCertificateRequest::getSecurityToken()const
 {
 	return securityToken_;