DCDN SDK Auto Released By xiaoyao,Version：1.27.4

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

CHANGELOG

@@ -1,3 +1,6 @@
+2018-09-29 Version: 1.27.4
+1, Sync cdn api.
+
 2018-09-29 Version: 1.27.3
 1, This is an example of release-log.
 2, Please strictly follow this format to edit in English.

VERSION

@@ -1 +1 @@
-1.27.3
+1.27.4

dcdn/CMakeLists.txt

@@ -29,8 +29,12 @@ set(dcdn_public_header_model
 	include/alibabacloud/dcdn/model/SetDcdnDomainCertificateResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainLogRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainLogResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnUserQuotaRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnUserQuotaResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainOriginBpsDataRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainOriginBpsDataResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainCertificateInfoRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainCertificateInfoResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnRefreshTasksRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnRefreshTasksResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnServiceRequest.h
@@ -59,10 +63,16 @@ set(dcdn_public_header_model
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainTrafficDataResult.h
 	include/alibabacloud/dcdn/model/RefreshDcdnObjectCachesRequest.h
 	include/alibabacloud/dcdn/model/RefreshDcdnObjectCachesResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnTopDomainsByFlowRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnTopDomainsByFlowResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainRegionDataRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainRegionDataResult.h
 	include/alibabacloud/dcdn/model/DescribeUserDcdnStatusRequest.h
 	include/alibabacloud/dcdn/model/DescribeUserDcdnStatusResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainQpsDataRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainQpsDataResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainIspDataRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainIspDataResult.h
 	include/alibabacloud/dcdn/model/StartDcdnDomainRequest.h
 	include/alibabacloud/dcdn/model/StartDcdnDomainResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnUserDomainsRequest.h
@@ -88,8 +98,12 @@ set(dcdn_src
 	src/model/SetDcdnDomainCertificateResult.cc
 	src/model/DescribeDcdnDomainLogRequest.cc
 	src/model/DescribeDcdnDomainLogResult.cc
+	src/model/DescribeDcdnUserQuotaRequest.cc
+	src/model/DescribeDcdnUserQuotaResult.cc
 	src/model/DescribeDcdnDomainOriginBpsDataRequest.cc
 	src/model/DescribeDcdnDomainOriginBpsDataResult.cc
+	src/model/DescribeDcdnDomainCertificateInfoRequest.cc
+	src/model/DescribeDcdnDomainCertificateInfoResult.cc
 	src/model/DescribeDcdnRefreshTasksRequest.cc
 	src/model/DescribeDcdnRefreshTasksResult.cc
 	src/model/DescribeDcdnServiceRequest.cc
@@ -118,10 +132,16 @@ set(dcdn_src
 	src/model/DescribeDcdnDomainTrafficDataResult.cc
 	src/model/RefreshDcdnObjectCachesRequest.cc
 	src/model/RefreshDcdnObjectCachesResult.cc
+	src/model/DescribeDcdnTopDomainsByFlowRequest.cc
+	src/model/DescribeDcdnTopDomainsByFlowResult.cc
+	src/model/DescribeDcdnDomainRegionDataRequest.cc
+	src/model/DescribeDcdnDomainRegionDataResult.cc
 	src/model/DescribeUserDcdnStatusRequest.cc
 	src/model/DescribeUserDcdnStatusResult.cc
 	src/model/DescribeDcdnDomainQpsDataRequest.cc
 	src/model/DescribeDcdnDomainQpsDataResult.cc
+	src/model/DescribeDcdnDomainIspDataRequest.cc
+	src/model/DescribeDcdnDomainIspDataResult.cc
 	src/model/StartDcdnDomainRequest.cc
 	src/model/StartDcdnDomainResult.cc
 	src/model/DescribeDcdnUserDomainsRequest.cc

dcdn/include/alibabacloud/dcdn/DcdnClient.h

@@ -30,8 +30,12 @@
 #include "model/SetDcdnDomainCertificateResult.h"
 #include "model/DescribeDcdnDomainLogRequest.h"
 #include "model/DescribeDcdnDomainLogResult.h"
+#include "model/DescribeDcdnUserQuotaRequest.h"
+#include "model/DescribeDcdnUserQuotaResult.h"
 #include "model/DescribeDcdnDomainOriginBpsDataRequest.h"
 #include "model/DescribeDcdnDomainOriginBpsDataResult.h"
+#include "model/DescribeDcdnDomainCertificateInfoRequest.h"
+#include "model/DescribeDcdnDomainCertificateInfoResult.h"
 #include "model/DescribeDcdnRefreshTasksRequest.h"
 #include "model/DescribeDcdnRefreshTasksResult.h"
 #include "model/DescribeDcdnServiceRequest.h"
@@ -60,10 +64,16 @@
 #include "model/DescribeDcdnDomainTrafficDataResult.h"
 #include "model/RefreshDcdnObjectCachesRequest.h"
 #include "model/RefreshDcdnObjectCachesResult.h"
+#include "model/DescribeDcdnTopDomainsByFlowRequest.h"
+#include "model/DescribeDcdnTopDomainsByFlowResult.h"
+#include "model/DescribeDcdnDomainRegionDataRequest.h"
+#include "model/DescribeDcdnDomainRegionDataResult.h"
 #include "model/DescribeUserDcdnStatusRequest.h"
 #include "model/DescribeUserDcdnStatusResult.h"
 #include "model/DescribeDcdnDomainQpsDataRequest.h"
 #include "model/DescribeDcdnDomainQpsDataResult.h"
+#include "model/DescribeDcdnDomainIspDataRequest.h"
+#include "model/DescribeDcdnDomainIspDataResult.h"
 #include "model/StartDcdnDomainRequest.h"
 #include "model/StartDcdnDomainResult.h"
 #include "model/DescribeDcdnUserDomainsRequest.h"
@@ -99,9 +109,15 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDcdnDomainLogResult> DescribeDcdnDomainLogOutcome;
 			typedef std::future<DescribeDcdnDomainLogOutcome> DescribeDcdnDomainLogOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainLogRequest&, const DescribeDcdnDomainLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainLogAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnUserQuotaResult> DescribeDcdnUserQuotaOutcome;
+			typedef std::future<DescribeDcdnUserQuotaOutcome> DescribeDcdnUserQuotaOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnUserQuotaRequest&, const DescribeDcdnUserQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnUserQuotaAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnDomainOriginBpsDataResult> DescribeDcdnDomainOriginBpsDataOutcome;
 			typedef std::future<DescribeDcdnDomainOriginBpsDataOutcome> DescribeDcdnDomainOriginBpsDataOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainOriginBpsDataRequest&, const DescribeDcdnDomainOriginBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainOriginBpsDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnDomainCertificateInfoResult> DescribeDcdnDomainCertificateInfoOutcome;
+			typedef std::future<DescribeDcdnDomainCertificateInfoOutcome> DescribeDcdnDomainCertificateInfoOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainCertificateInfoRequest&, const DescribeDcdnDomainCertificateInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainCertificateInfoAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnRefreshTasksResult> DescribeDcdnRefreshTasksOutcome;
 			typedef std::future<DescribeDcdnRefreshTasksOutcome> DescribeDcdnRefreshTasksOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnRefreshTasksRequest&, const DescribeDcdnRefreshTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnRefreshTasksAsyncHandler;
@@ -144,12 +160,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RefreshDcdnObjectCachesResult> RefreshDcdnObjectCachesOutcome;
 			typedef std::future<RefreshDcdnObjectCachesOutcome> RefreshDcdnObjectCachesOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::RefreshDcdnObjectCachesRequest&, const RefreshDcdnObjectCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RefreshDcdnObjectCachesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnTopDomainsByFlowResult> DescribeDcdnTopDomainsByFlowOutcome;
+			typedef std::future<DescribeDcdnTopDomainsByFlowOutcome> DescribeDcdnTopDomainsByFlowOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnTopDomainsByFlowRequest&, const DescribeDcdnTopDomainsByFlowOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnTopDomainsByFlowAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnDomainRegionDataResult> DescribeDcdnDomainRegionDataOutcome;
+			typedef std::future<DescribeDcdnDomainRegionDataOutcome> DescribeDcdnDomainRegionDataOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainRegionDataRequest&, const DescribeDcdnDomainRegionDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainRegionDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeUserDcdnStatusResult> DescribeUserDcdnStatusOutcome;
 			typedef std::future<DescribeUserDcdnStatusOutcome> DescribeUserDcdnStatusOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeUserDcdnStatusRequest&, const DescribeUserDcdnStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserDcdnStatusAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnDomainQpsDataResult> DescribeDcdnDomainQpsDataOutcome;
 			typedef std::future<DescribeDcdnDomainQpsDataOutcome> DescribeDcdnDomainQpsDataOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainQpsDataRequest&, const DescribeDcdnDomainQpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainQpsDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnDomainIspDataResult> DescribeDcdnDomainIspDataOutcome;
+			typedef std::future<DescribeDcdnDomainIspDataOutcome> DescribeDcdnDomainIspDataOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainIspDataRequest&, const DescribeDcdnDomainIspDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainIspDataAsyncHandler;
 			typedef Outcome<Error, Model::StartDcdnDomainResult> StartDcdnDomainOutcome;
 			typedef std::future<StartDcdnDomainOutcome> StartDcdnDomainOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::StartDcdnDomainRequest&, const StartDcdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartDcdnDomainAsyncHandler;
@@ -188,9 +213,15 @@ namespace AlibabaCloud
 			DescribeDcdnDomainLogOutcome describeDcdnDomainLog(const Model::DescribeDcdnDomainLogRequest &request)const;
 			void describeDcdnDomainLogAsync(const Model::DescribeDcdnDomainLogRequest& request, const DescribeDcdnDomainLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnDomainLogOutcomeCallable describeDcdnDomainLogCallable(const Model::DescribeDcdnDomainLogRequest& request) const;
+			DescribeDcdnUserQuotaOutcome describeDcdnUserQuota(const Model::DescribeDcdnUserQuotaRequest &request)const;
+			void describeDcdnUserQuotaAsync(const Model::DescribeDcdnUserQuotaRequest& request, const DescribeDcdnUserQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnUserQuotaOutcomeCallable describeDcdnUserQuotaCallable(const Model::DescribeDcdnUserQuotaRequest& request) const;
 			DescribeDcdnDomainOriginBpsDataOutcome describeDcdnDomainOriginBpsData(const Model::DescribeDcdnDomainOriginBpsDataRequest &request)const;
 			void describeDcdnDomainOriginBpsDataAsync(const Model::DescribeDcdnDomainOriginBpsDataRequest& request, const DescribeDcdnDomainOriginBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnDomainOriginBpsDataOutcomeCallable describeDcdnDomainOriginBpsDataCallable(const Model::DescribeDcdnDomainOriginBpsDataRequest& request) const;
+			DescribeDcdnDomainCertificateInfoOutcome describeDcdnDomainCertificateInfo(const Model::DescribeDcdnDomainCertificateInfoRequest &request)const;
+			void describeDcdnDomainCertificateInfoAsync(const Model::DescribeDcdnDomainCertificateInfoRequest& request, const DescribeDcdnDomainCertificateInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnDomainCertificateInfoOutcomeCallable describeDcdnDomainCertificateInfoCallable(const Model::DescribeDcdnDomainCertificateInfoRequest& request) const;
 			DescribeDcdnRefreshTasksOutcome describeDcdnRefreshTasks(const Model::DescribeDcdnRefreshTasksRequest &request)const;
 			void describeDcdnRefreshTasksAsync(const Model::DescribeDcdnRefreshTasksRequest& request, const DescribeDcdnRefreshTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnRefreshTasksOutcomeCallable describeDcdnRefreshTasksCallable(const Model::DescribeDcdnRefreshTasksRequest& request) const;
@@ -233,12 +264,21 @@ namespace AlibabaCloud
 			RefreshDcdnObjectCachesOutcome refreshDcdnObjectCaches(const Model::RefreshDcdnObjectCachesRequest &request)const;
 			void refreshDcdnObjectCachesAsync(const Model::RefreshDcdnObjectCachesRequest& request, const RefreshDcdnObjectCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RefreshDcdnObjectCachesOutcomeCallable refreshDcdnObjectCachesCallable(const Model::RefreshDcdnObjectCachesRequest& request) const;
+			DescribeDcdnTopDomainsByFlowOutcome describeDcdnTopDomainsByFlow(const Model::DescribeDcdnTopDomainsByFlowRequest &request)const;
+			void describeDcdnTopDomainsByFlowAsync(const Model::DescribeDcdnTopDomainsByFlowRequest& request, const DescribeDcdnTopDomainsByFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnTopDomainsByFlowOutcomeCallable describeDcdnTopDomainsByFlowCallable(const Model::DescribeDcdnTopDomainsByFlowRequest& request) const;
+			DescribeDcdnDomainRegionDataOutcome describeDcdnDomainRegionData(const Model::DescribeDcdnDomainRegionDataRequest &request)const;
+			void describeDcdnDomainRegionDataAsync(const Model::DescribeDcdnDomainRegionDataRequest& request, const DescribeDcdnDomainRegionDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnDomainRegionDataOutcomeCallable describeDcdnDomainRegionDataCallable(const Model::DescribeDcdnDomainRegionDataRequest& request) const;
 			DescribeUserDcdnStatusOutcome describeUserDcdnStatus(const Model::DescribeUserDcdnStatusRequest &request)const;
 			void describeUserDcdnStatusAsync(const Model::DescribeUserDcdnStatusRequest& request, const DescribeUserDcdnStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeUserDcdnStatusOutcomeCallable describeUserDcdnStatusCallable(const Model::DescribeUserDcdnStatusRequest& request) const;
 			DescribeDcdnDomainQpsDataOutcome describeDcdnDomainQpsData(const Model::DescribeDcdnDomainQpsDataRequest &request)const;
 			void describeDcdnDomainQpsDataAsync(const Model::DescribeDcdnDomainQpsDataRequest& request, const DescribeDcdnDomainQpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnDomainQpsDataOutcomeCallable describeDcdnDomainQpsDataCallable(const Model::DescribeDcdnDomainQpsDataRequest& request) const;
+			DescribeDcdnDomainIspDataOutcome describeDcdnDomainIspData(const Model::DescribeDcdnDomainIspDataRequest &request)const;
+			void describeDcdnDomainIspDataAsync(const Model::DescribeDcdnDomainIspDataRequest& request, const DescribeDcdnDomainIspDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnDomainIspDataOutcomeCallable describeDcdnDomainIspDataCallable(const Model::DescribeDcdnDomainIspDataRequest& request) const;
 			StartDcdnDomainOutcome startDcdnDomain(const Model::StartDcdnDomainRequest &request)const;
 			void startDcdnDomainAsync(const Model::StartDcdnDomainRequest& request, const StartDcdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StartDcdnDomainOutcomeCallable startDcdnDomainCallable(const Model::StartDcdnDomainRequest& request) const;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainBpsDataRequest.h

@@ -65,6 +65,8 @@ namespace AlibabaCloud
 				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 getFixTimeGap()const;
@@ -110,6 +112,7 @@ namespace AlibabaCloud
 				std::string callerUidEmail_;
 				long callerUid_;
 				std::string app_ip_;
+				std::string popProduct_;
 				std::string product_;
 				std::string fixTimeGap_;
 				std::string timeMerge_;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainCertificateInfoRequest.h

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DCDN_MODEL_DESCRIBEDCDNDOMAINCERTIFICATEINFOREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINCERTIFICATEINFOREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnDomainCertificateInfoRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnDomainCertificateInfoRequest();
+				~DescribeDcdnDomainCertificateInfoRequest();
+
+				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);
+				long getCallerParentId()const;
+				void setCallerParentId(long callerParentId);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				bool getProxy_original_security_transport()const;
+				void setProxy_original_security_transport(bool proxy_original_security_transport);
+				std::string getCallerBid()const;
+				void setCallerBid(const std::string& callerBid);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getProxy_original_source_ip()const;
+				void setProxy_original_source_ip(const std::string& proxy_original_source_ip);
+				std::string getVersion()const;
+				void setVersion(const std::string& version);
+				std::string getOwnerIdLoginEmail()const;
+				void setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail);
+				std::string getCallerType()const;
+				void setCallerType(const std::string& callerType);
+				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);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				bool getSecurity_transport()const;
+				void setSecurity_transport(bool security_transport);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getRequestId()const;
+				void setRequestId(const std::string& requestId);
+				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);
+
+            private:
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string product_;
+				long callerParentId_;
+				std::string domainName_;
+				bool proxy_original_security_transport_;
+				std::string callerBid_;
+				long ownerId_;
+				std::string proxy_original_source_ip_;
+				std::string version_;
+				std::string ownerIdLoginEmail_;
+				std::string callerType_;
+				bool proxy_trust_transport_info_;
+				bool ak_mfa_present_;
+				std::string accessKeyId_;
+				bool security_transport_;
+				std::string securityToken_;
+				std::string requestId_;
+				std::string requestContent_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINCERTIFICATEINFOREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainCertificateInfoResult.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_DCDN_MODEL_DESCRIBEDCDNDOMAINCERTIFICATEINFORESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINCERTIFICATEINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnDomainCertificateInfoResult : public ServiceResult
+			{
+			public:
+				struct CertInfo
+				{
+					std::string status;
+					std::string certLife;
+					std::string domainName;
+					std::string sSLPub;
+					std::string certDomainName;
+					std::string certOrg;
+					std::string certType;
+					std::string certExpireTime;
+					std::string certName;
+					std::string sSLProtocol;
+				};
+
+
+				DescribeDcdnDomainCertificateInfoResult();
+				explicit DescribeDcdnDomainCertificateInfoResult(const std::string &payload);
+				~DescribeDcdnDomainCertificateInfoResult();
+				std::vector<CertInfo> getCertInfos()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<CertInfo> certInfos_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINCERTIFICATEINFORESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainCnameRequest.h

@@ -37,6 +37,8 @@ namespace AlibabaCloud
 
 				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);
 				long getCallerParentId()const;
@@ -80,6 +82,7 @@ namespace AlibabaCloud
 
             private:
 				std::string app_ip_;
+				std::string popProduct_;
 				std::string product_;
 				long callerParentId_;
 				std::string domainName_;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainDetailResult.h

@@ -41,6 +41,7 @@ namespace AlibabaCloud
 						std::string priority;
 						int port;
 						std::string enabled;
+						std::string weight;
 					};
 					std::string description;
 					std::string scope;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainHitRateDataRequest.h

@@ -61,6 +61,8 @@ namespace AlibabaCloud
 				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;
@@ -100,6 +102,7 @@ namespace AlibabaCloud
 				std::string callerUidEmail_;
 				long callerUid_;
 				std::string app_ip_;
+				std::string popProduct_;
 				std::string product_;
 				std::string domainName_;
 				std::string endTime_;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainHttpCodeDataRequest.h

@@ -65,6 +65,8 @@ namespace AlibabaCloud
 				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;
@@ -106,6 +108,7 @@ namespace AlibabaCloud
 				std::string callerUidEmail_;
 				long callerUid_;
 				std::string app_ip_;
+				std::string popProduct_;
 				std::string product_;
 				std::string domainName_;
 				std::string endTime_;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainIspDataRequest.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_DCDN_MODEL_DESCRIBEDCDNDOMAINISPDATAREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINISPDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnDomainIspDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnDomainIspDataRequest();
+				~DescribeDcdnDomainIspDataRequest();
+
+				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_DCDN_MODEL_DESCRIBEDCDNDOMAINISPDATAREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainIspDataResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DCDN_MODEL_DESCRIBEDCDNDOMAINISPDATARESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINISPDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnDomainIspDataResult : public ServiceResult
+			{
+			public:
+				struct IspProportionData
+				{
+					std::string avgObjectSize;
+					std::string bytesProportion;
+					std::string bps;
+					std::string proportion;
+					std::string qps;
+					std::string totalQuery;
+					std::string isp;
+					std::string totalBytes;
+					std::string avgResponseRate;
+					std::string ispEname;
+					std::string avgResponseTime;
+				};
+
+
+				DescribeDcdnDomainIspDataResult();
+				explicit DescribeDcdnDomainIspDataResult(const std::string &payload);
+				~DescribeDcdnDomainIspDataResult();
+				std::string getEndTime()const;
+				std::string getDomainName()const;
+				std::vector<IspProportionData> 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<IspProportionData> value_;
+				std::string dataInterval_;
+				std::string startTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINISPDATARESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainLogRequest.h

@@ -65,6 +65,8 @@ namespace AlibabaCloud
 				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;
@@ -102,6 +104,7 @@ namespace AlibabaCloud
 				std::string callerUidEmail_;
 				long callerUid_;
 				std::string app_ip_;
+				std::string popProduct_;
 				std::string product_;
 				std::string domainName_;
 				std::string endTime_;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainOriginBpsDataRequest.h

@@ -61,6 +61,8 @@ namespace AlibabaCloud
 				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 getFixTimeGap()const;
@@ -104,6 +106,7 @@ namespace AlibabaCloud
 				std::string callerUidEmail_;
 				long callerUid_;
 				std::string app_ip_;
+				std::string popProduct_;
 				std::string product_;
 				std::string fixTimeGap_;
 				std::string timeMerge_;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainOriginTrafficDataRequest.h

@@ -61,6 +61,8 @@ namespace AlibabaCloud
 				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 getFixTimeGap()const;
@@ -104,6 +106,7 @@ namespace AlibabaCloud
 				std::string callerUidEmail_;
 				long callerUid_;
 				std::string app_ip_;
+				std::string popProduct_;
 				std::string product_;
 				std::string fixTimeGap_;
 				std::string timeMerge_;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainQpsDataRequest.h

@@ -65,6 +65,8 @@ namespace AlibabaCloud
 				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 getFixTimeGap()const;
@@ -110,6 +112,7 @@ namespace AlibabaCloud
 				std::string callerUidEmail_;
 				long callerUid_;
 				std::string app_ip_;
+				std::string popProduct_;
 				std::string product_;
 				std::string fixTimeGap_;
 				std::string timeMerge_;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainRegionDataRequest.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_DCDN_MODEL_DESCRIBEDCDNDOMAINREGIONDATAREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREGIONDATAREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnDomainRegionDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnDomainRegionDataRequest();
+				~DescribeDcdnDomainRegionDataRequest();
+
+				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_DCDN_MODEL_DESCRIBEDCDNDOMAINREGIONDATAREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainRegionDataResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DCDN_MODEL_DESCRIBEDCDNDOMAINREGIONDATARESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREGIONDATARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnDomainRegionDataResult : 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 regionEname;
+					std::string avgResponseTime;
+				};
+
+
+				DescribeDcdnDomainRegionDataResult();
+				explicit DescribeDcdnDomainRegionDataResult(const std::string &payload);
+				~DescribeDcdnDomainRegionDataResult();
+				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_DCDN_MODEL_DESCRIBEDCDNDOMAINREGIONDATARESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainTrafficDataRequest.h

@@ -65,6 +65,8 @@ namespace AlibabaCloud
 				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 getFixTimeGap()const;
@@ -110,6 +112,7 @@ namespace AlibabaCloud
 				std::string callerUidEmail_;
 				long callerUid_;
 				std::string app_ip_;
+				std::string popProduct_;
 				std::string product_;
 				std::string fixTimeGap_;
 				std::string timeMerge_;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnServiceResult.h

@@ -41,22 +41,28 @@ namespace AlibabaCloud
 				DescribeDcdnServiceResult();
 				explicit DescribeDcdnServiceResult(const std::string &payload);
 				~DescribeDcdnServiceResult();
+				std::string getWebsocketChangingType()const;
 				std::string getChangingChargeType()const;
 				std::string getInstanceId()const;
+				std::string getWebsocketType()const;
 				std::string getOpeningTime()const;
 				std::vector<LockReason> getOperationLocks()const;
 				std::string getChangingAffectTime()const;
 				std::string getInternetChargeType()const;
+				std::string getWebsocketChangingTime()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string websocketChangingType_;
 				std::string changingChargeType_;
 				std::string instanceId_;
+				std::string websocketType_;
 				std::string openingTime_;
 				std::vector<LockReason> operationLocks_;
 				std::string changingAffectTime_;
 				std::string internetChargeType_;
+				std::string websocketChangingTime_;
 
 			};
 		}

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnTopDomainsByFlowRequest.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_DCDN_MODEL_DESCRIBEDCDNTOPDOMAINSBYFLOWREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNTOPDOMAINSBYFLOWREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnTopDomainsByFlowRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnTopDomainsByFlowRequest();
+				~DescribeDcdnTopDomainsByFlowRequest();
+
+				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 getAoneId()const;
+				void setAoneId(const std::string& aoneId);
+				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 getMethod()const;
+				void setMethod(const std::string& method);
+				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 getCategory()const;
+				void setCategory(const std::string& category);
+
+            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 aoneId_;
+				std::string requestContent_;
+				long limit_;
+				std::string callerBidEmail_;
+				std::string callerUidEmail_;
+				long callerUid_;
+				std::string app_ip_;
+				std::string popProduct_;
+				std::string method_;
+				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 category_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNTOPDOMAINSBYFLOWREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnTopDomainsByFlowResult.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_DCDN_MODEL_DESCRIBEDCDNTOPDOMAINSBYFLOWRESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNTOPDOMAINSBYFLOWRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnTopDomainsByFlowResult : public ServiceResult
+			{
+			public:
+				struct TopDomain
+				{
+					long maxBps;
+					std::string domainName;
+					std::string maxBpsTime;
+					long rank;
+					std::string totalTraffic;
+					long totalAccess;
+					std::string trafficPercent;
+				};
+
+
+				DescribeDcdnTopDomainsByFlowResult();
+				explicit DescribeDcdnTopDomainsByFlowResult(const std::string &payload);
+				~DescribeDcdnTopDomainsByFlowResult();
+				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_DCDN_MODEL_DESCRIBEDCDNTOPDOMAINSBYFLOWRESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserDomainsResult.h

@@ -40,6 +40,7 @@ namespace AlibabaCloud
 						std::string content;
 						std::string priority;
 						int port;
+						std::string weight;
 					};
 					std::string description;
 					std::string resourceGroupId;

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserQuotaRequest.h

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

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserQuotaResult.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERQUOTARESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERQUOTARESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Dcdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_DCDN_EXPORT DescribeDcdnUserQuotaResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDcdnUserQuotaResult();
+				explicit DescribeDcdnUserQuotaResult(const std::string &payload);
+				~DescribeDcdnUserQuotaResult();
+				int getRefreshUrlQuota()const;
+				int getPreloadRemain()const;
+				int getBlockRemain()const;
+				int getRefreshDirRemain()const;
+				int getRefreshDirQuota()const;
+				int getBlockQuota()const;
+				int getDomainQuota()const;
+				int getRefreshUrlRemain()const;
+				int getPreloadQuota()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int refreshUrlQuota_;
+				int preloadRemain_;
+				int blockRemain_;
+				int refreshDirRemain_;
+				int refreshDirQuota_;
+				int blockQuota_;
+				int domainQuota_;
+				int refreshUrlRemain_;
+				int preloadQuota_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERQUOTARESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserResourcePackageResult.h

@@ -36,9 +36,11 @@ namespace AlibabaCloud
 				{
 					std::string status;
 					std::string initCapacity;
+					std::string endTime;
 					std::string instanceId;
 					std::string commodityCode;
 					std::string displayName;
+					std::string startTime;
 					std::string currCapacity;
 				};
 

dcdn/include/alibabacloud/dcdn/model/PreloadDcdnObjectCachesRequest.h

@@ -35,6 +35,8 @@ namespace AlibabaCloud
 				PreloadDcdnObjectCachesRequest();
 				~PreloadDcdnObjectCachesRequest();
 
+				std::string getArea()const;
+				void setArea(const std::string& area);
 				std::string getSecurityToken()const;
 				void setSecurityToken(const std::string& securityToken);
 				std::string getObjectPath()const;
@@ -45,6 +47,7 @@ namespace AlibabaCloud
 				void setAccessKeyId(const std::string& accessKeyId);
 
             private:
+				std::string area_;
 				std::string securityToken_;
 				std::string objectPath_;
 				long ownerId_;

dcdn/src/DcdnClient.cc

@@ -31,21 +31,21 @@ DcdnClient::DcdnClient(const Credentials &credentials, const ClientConfiguration
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dcdn");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 DcdnClient::DcdnClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dcdn");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 DcdnClient::DcdnClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "dcdn");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 DcdnClient::~DcdnClient()
@@ -195,6 +195,42 @@ DcdnClient::DescribeDcdnDomainLogOutcomeCallable DcdnClient::describeDcdnDomainL
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnUserQuotaOutcome DcdnClient::describeDcdnUserQuota(const DescribeDcdnUserQuotaRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnUserQuotaOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnUserQuotaOutcome(DescribeDcdnUserQuotaResult(outcome.result()));
+	else
+		return DescribeDcdnUserQuotaOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnUserQuotaAsync(const DescribeDcdnUserQuotaRequest& request, const DescribeDcdnUserQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnUserQuota(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnUserQuotaOutcomeCallable DcdnClient::describeDcdnUserQuotaCallable(const DescribeDcdnUserQuotaRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnUserQuotaOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnUserQuota(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnDomainOriginBpsDataOutcome DcdnClient::describeDcdnDomainOriginBpsData(const DescribeDcdnDomainOriginBpsDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -231,6 +267,42 @@ DcdnClient::DescribeDcdnDomainOriginBpsDataOutcomeCallable DcdnClient::describeD
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnDomainCertificateInfoOutcome DcdnClient::describeDcdnDomainCertificateInfo(const DescribeDcdnDomainCertificateInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnDomainCertificateInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnDomainCertificateInfoOutcome(DescribeDcdnDomainCertificateInfoResult(outcome.result()));
+	else
+		return DescribeDcdnDomainCertificateInfoOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnDomainCertificateInfoAsync(const DescribeDcdnDomainCertificateInfoRequest& request, const DescribeDcdnDomainCertificateInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnDomainCertificateInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnDomainCertificateInfoOutcomeCallable DcdnClient::describeDcdnDomainCertificateInfoCallable(const DescribeDcdnDomainCertificateInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnDomainCertificateInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnDomainCertificateInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnRefreshTasksOutcome DcdnClient::describeDcdnRefreshTasks(const DescribeDcdnRefreshTasksRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -735,6 +807,78 @@ DcdnClient::RefreshDcdnObjectCachesOutcomeCallable DcdnClient::refreshDcdnObject
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnTopDomainsByFlowOutcome DcdnClient::describeDcdnTopDomainsByFlow(const DescribeDcdnTopDomainsByFlowRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnTopDomainsByFlowOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnTopDomainsByFlowOutcome(DescribeDcdnTopDomainsByFlowResult(outcome.result()));
+	else
+		return DescribeDcdnTopDomainsByFlowOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnTopDomainsByFlowAsync(const DescribeDcdnTopDomainsByFlowRequest& request, const DescribeDcdnTopDomainsByFlowAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnTopDomainsByFlow(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnTopDomainsByFlowOutcomeCallable DcdnClient::describeDcdnTopDomainsByFlowCallable(const DescribeDcdnTopDomainsByFlowRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnTopDomainsByFlowOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnTopDomainsByFlow(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DcdnClient::DescribeDcdnDomainRegionDataOutcome DcdnClient::describeDcdnDomainRegionData(const DescribeDcdnDomainRegionDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnDomainRegionDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnDomainRegionDataOutcome(DescribeDcdnDomainRegionDataResult(outcome.result()));
+	else
+		return DescribeDcdnDomainRegionDataOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnDomainRegionDataAsync(const DescribeDcdnDomainRegionDataRequest& request, const DescribeDcdnDomainRegionDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnDomainRegionData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnDomainRegionDataOutcomeCallable DcdnClient::describeDcdnDomainRegionDataCallable(const DescribeDcdnDomainRegionDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnDomainRegionDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnDomainRegionData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeUserDcdnStatusOutcome DcdnClient::describeUserDcdnStatus(const DescribeUserDcdnStatusRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -807,6 +951,42 @@ DcdnClient::DescribeDcdnDomainQpsDataOutcomeCallable DcdnClient::describeDcdnDom
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnDomainIspDataOutcome DcdnClient::describeDcdnDomainIspData(const DescribeDcdnDomainIspDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnDomainIspDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnDomainIspDataOutcome(DescribeDcdnDomainIspDataResult(outcome.result()));
+	else
+		return DescribeDcdnDomainIspDataOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnDomainIspDataAsync(const DescribeDcdnDomainIspDataRequest& request, const DescribeDcdnDomainIspDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnDomainIspData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnDomainIspDataOutcomeCallable DcdnClient::describeDcdnDomainIspDataCallable(const DescribeDcdnDomainIspDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnDomainIspDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnDomainIspData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::StartDcdnDomainOutcome DcdnClient::startDcdnDomain(const StartDcdnDomainRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dcdn/src/model/DescribeDcdnDomainBpsDataRequest.cc

@@ -190,6 +190,17 @@ void DescribeDcdnDomainBpsDataRequest::setApp_ip(const std::string& app_ip)
 	setParameter("App_ip", app_ip);
 }
 
+std::string DescribeDcdnDomainBpsDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainBpsDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
 std::string DescribeDcdnDomainBpsDataRequest::getProduct()const
 {
 	return product_;

dcdn/src/model/DescribeDcdnDomainCertificateInfoRequest.cc

@@ -0,0 +1,269 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/dcdn/model/DescribeDcdnDomainCertificateInfoRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnDomainCertificateInfoRequest;
+
+DescribeDcdnDomainCertificateInfoRequest::DescribeDcdnDomainCertificateInfoRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnDomainCertificateInfo")
+{}
+
+DescribeDcdnDomainCertificateInfoRequest::~DescribeDcdnDomainCertificateInfoRequest()
+{}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+long DescribeDcdnDomainCertificateInfoRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+bool DescribeDcdnDomainCertificateInfoRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::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 DescribeDcdnDomainCertificateInfoRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeDcdnDomainCertificateInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::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 DescribeDcdnDomainCertificateInfoRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+bool DescribeDcdnDomainCertificateInfoRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::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 DescribeDcdnDomainCertificateInfoRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+bool DescribeDcdnDomainCertificateInfoRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeDcdnDomainCertificateInfoRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeDcdnDomainCertificateInfoRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeDcdnDomainCertificateInfoRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+

dcdn/src/model/DescribeDcdnDomainCertificateInfoResult.cc

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnDomainCertificateInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnDomainCertificateInfoResult::DescribeDcdnDomainCertificateInfoResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnDomainCertificateInfoResult::DescribeDcdnDomainCertificateInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnDomainCertificateInfoResult::~DescribeDcdnDomainCertificateInfoResult()
+{}
+
+void DescribeDcdnDomainCertificateInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allCertInfos = value["CertInfos"]["CertInfo"];
+	for (auto value : allCertInfos)
+	{
+		CertInfo certInfosObject;
+		if(!value["DomainName"].isNull())
+			certInfosObject.domainName = value["DomainName"].asString();
+		if(!value["CertName"].isNull())
+			certInfosObject.certName = value["CertName"].asString();
+		if(!value["CertDomainName"].isNull())
+			certInfosObject.certDomainName = value["CertDomainName"].asString();
+		if(!value["CertExpireTime"].isNull())
+			certInfosObject.certExpireTime = value["CertExpireTime"].asString();
+		if(!value["CertLife"].isNull())
+			certInfosObject.certLife = value["CertLife"].asString();
+		if(!value["CertOrg"].isNull())
+			certInfosObject.certOrg = value["CertOrg"].asString();
+		if(!value["CertType"].isNull())
+			certInfosObject.certType = value["CertType"].asString();
+		if(!value["SSLProtocol"].isNull())
+			certInfosObject.sSLProtocol = value["SSLProtocol"].asString();
+		if(!value["Status"].isNull())
+			certInfosObject.status = value["Status"].asString();
+		if(!value["SSLPub"].isNull())
+			certInfosObject.sSLPub = value["SSLPub"].asString();
+		certInfos_.push_back(certInfosObject);
+	}
+
+}
+
+std::vector<DescribeDcdnDomainCertificateInfoResult::CertInfo> DescribeDcdnDomainCertificateInfoResult::getCertInfos()const
+{
+	return certInfos_;
+}
+

dcdn/src/model/DescribeDcdnDomainCnameRequest.cc

@@ -36,6 +36,17 @@ void DescribeDcdnDomainCnameRequest::setApp_ip(const std::string& app_ip)
 	setParameter("App_ip", app_ip);
 }
 
+std::string DescribeDcdnDomainCnameRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainCnameRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
 std::string DescribeDcdnDomainCnameRequest::getProduct()const
 {
 	return product_;

dcdn/src/model/DescribeDcdnDomainDetailResult.cc

@@ -77,6 +77,8 @@ void DescribeDcdnDomainDetailResult::parse(const std::string &payload)
 			sourceObject.enabled = value["Enabled"].asString();
 		if(!value["Priority"].isNull())
 			sourceObject.priority = value["Priority"].asString();
+		if(!value["Weight"].isNull())
+			sourceObject.weight = value["Weight"].asString();
 		domainDetail_.sources.push_back(sourceObject);
 	}
 

dcdn/src/model/DescribeDcdnDomainHitRateDataRequest.cc

@@ -168,6 +168,17 @@ void DescribeDcdnDomainHitRateDataRequest::setApp_ip(const std::string& app_ip)
 	setParameter("App_ip", app_ip);
 }
 
+std::string DescribeDcdnDomainHitRateDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainHitRateDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
 std::string DescribeDcdnDomainHitRateDataRequest::getProduct()const
 {
 	return product_;

dcdn/src/model/DescribeDcdnDomainHttpCodeDataRequest.cc

@@ -190,6 +190,17 @@ void DescribeDcdnDomainHttpCodeDataRequest::setApp_ip(const std::string& app_ip)
 	setParameter("App_ip", app_ip);
 }
 
+std::string DescribeDcdnDomainHttpCodeDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainHttpCodeDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
 std::string DescribeDcdnDomainHttpCodeDataRequest::getProduct()const
 {
 	return product_;

dcdn/src/model/DescribeDcdnDomainIspDataRequest.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/dcdn/model/DescribeDcdnDomainIspDataRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnDomainIspDataRequest;
+
+DescribeDcdnDomainIspDataRequest::DescribeDcdnDomainIspDataRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnDomainIspData")
+{}
+
+DescribeDcdnDomainIspDataRequest::~DescribeDcdnDomainIspDataRequest()
+{}
+
+long DescribeDcdnDomainIspDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeDcdnDomainIspDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeDcdnDomainIspDataRequest::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 DescribeDcdnDomainIspDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeDcdnDomainIspDataRequest::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 DescribeDcdnDomainIspDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeDcdnDomainIspDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeDcdnDomainIspDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeDcdnDomainIspDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeDcdnDomainIspDataRequest::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 DescribeDcdnDomainIspDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeDcdnDomainIspDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeDcdnDomainIspDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeDcdnDomainIspDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+

dcdn/src/model/DescribeDcdnDomainIspDataResult.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/dcdn/model/DescribeDcdnDomainIspDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnDomainIspDataResult::DescribeDcdnDomainIspDataResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnDomainIspDataResult::DescribeDcdnDomainIspDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnDomainIspDataResult::~DescribeDcdnDomainIspDataResult()
+{}
+
+void DescribeDcdnDomainIspDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allValue = value["Value"]["IspProportionData"];
+	for (auto value : allValue)
+	{
+		IspProportionData valueObject;
+		if(!value["Isp"].isNull())
+			valueObject.isp = value["Isp"].asString();
+		if(!value["Proportion"].isNull())
+			valueObject.proportion = value["Proportion"].asString();
+		if(!value["IspEname"].isNull())
+			valueObject.ispEname = value["IspEname"].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["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 DescribeDcdnDomainIspDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeDcdnDomainIspDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::vector<DescribeDcdnDomainIspDataResult::IspProportionData> DescribeDcdnDomainIspDataResult::getValue()const
+{
+	return value_;
+}
+
+std::string DescribeDcdnDomainIspDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+
+std::string DescribeDcdnDomainIspDataResult::getStartTime()const
+{
+	return startTime_;
+}
+

dcdn/src/model/DescribeDcdnDomainLogRequest.cc

@@ -190,6 +190,17 @@ void DescribeDcdnDomainLogRequest::setApp_ip(const std::string& app_ip)
 	setParameter("App_ip", app_ip);
 }
 
+std::string DescribeDcdnDomainLogRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainLogRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
 std::string DescribeDcdnDomainLogRequest::getProduct()const
 {
 	return product_;

dcdn/src/model/DescribeDcdnDomainOriginBpsDataRequest.cc

@@ -168,6 +168,17 @@ void DescribeDcdnDomainOriginBpsDataRequest::setApp_ip(const std::string& app_ip
 	setParameter("App_ip", app_ip);
 }
 
+std::string DescribeDcdnDomainOriginBpsDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainOriginBpsDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
 std::string DescribeDcdnDomainOriginBpsDataRequest::getProduct()const
 {
 	return product_;

dcdn/src/model/DescribeDcdnDomainOriginTrafficDataRequest.cc

@@ -168,6 +168,17 @@ void DescribeDcdnDomainOriginTrafficDataRequest::setApp_ip(const std::string& ap
 	setParameter("App_ip", app_ip);
 }
 
+std::string DescribeDcdnDomainOriginTrafficDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainOriginTrafficDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
 std::string DescribeDcdnDomainOriginTrafficDataRequest::getProduct()const
 {
 	return product_;

dcdn/src/model/DescribeDcdnDomainQpsDataRequest.cc

@@ -190,6 +190,17 @@ void DescribeDcdnDomainQpsDataRequest::setApp_ip(const std::string& app_ip)
 	setParameter("App_ip", app_ip);
 }
 
+std::string DescribeDcdnDomainQpsDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainQpsDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
 std::string DescribeDcdnDomainQpsDataRequest::getProduct()const
 {
 	return product_;

dcdn/src/model/DescribeDcdnDomainRegionDataRequest.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/dcdn/model/DescribeDcdnDomainRegionDataRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnDomainRegionDataRequest;
+
+DescribeDcdnDomainRegionDataRequest::DescribeDcdnDomainRegionDataRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnDomainRegionData")
+{}
+
+DescribeDcdnDomainRegionDataRequest::~DescribeDcdnDomainRegionDataRequest()
+{}
+
+long DescribeDcdnDomainRegionDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeDcdnDomainRegionDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::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 DescribeDcdnDomainRegionDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::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 DescribeDcdnDomainRegionDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeDcdnDomainRegionDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeDcdnDomainRegionDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeDcdnDomainRegionDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::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 DescribeDcdnDomainRegionDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeDcdnDomainRegionDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeDcdnDomainRegionDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeDcdnDomainRegionDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+

dcdn/src/model/DescribeDcdnDomainRegionDataResult.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/dcdn/model/DescribeDcdnDomainRegionDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnDomainRegionDataResult::DescribeDcdnDomainRegionDataResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnDomainRegionDataResult::DescribeDcdnDomainRegionDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnDomainRegionDataResult::~DescribeDcdnDomainRegionDataResult()
+{}
+
+void DescribeDcdnDomainRegionDataResult::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["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 DescribeDcdnDomainRegionDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeDcdnDomainRegionDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::vector<DescribeDcdnDomainRegionDataResult::RegionProportionData> DescribeDcdnDomainRegionDataResult::getValue()const
+{
+	return value_;
+}
+
+std::string DescribeDcdnDomainRegionDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+
+std::string DescribeDcdnDomainRegionDataResult::getStartTime()const
+{
+	return startTime_;
+}
+

dcdn/src/model/DescribeDcdnDomainTrafficDataRequest.cc

@@ -190,6 +190,17 @@ void DescribeDcdnDomainTrafficDataRequest::setApp_ip(const std::string& app_ip)
 	setParameter("App_ip", app_ip);
 }
 
+std::string DescribeDcdnDomainTrafficDataRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnDomainTrafficDataRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
 std::string DescribeDcdnDomainTrafficDataRequest::getProduct()const
 {
 	return product_;

dcdn/src/model/DescribeDcdnServiceResult.cc

@@ -58,9 +58,20 @@ void DescribeDcdnServiceResult::parse(const std::string &payload)
 		changingChargeType_ = value["ChangingChargeType"].asString();
 	if(!value["ChangingAffectTime"].isNull())
 		changingAffectTime_ = value["ChangingAffectTime"].asString();
+	if(!value["WebsocketChangingType"].isNull())
+		websocketChangingType_ = value["WebsocketChangingType"].asString();
+	if(!value["WebsocketType"].isNull())
+		websocketType_ = value["WebsocketType"].asString();
+	if(!value["WebsocketChangingTime"].isNull())
+		websocketChangingTime_ = value["WebsocketChangingTime"].asString();
 
 }
 
+std::string DescribeDcdnServiceResult::getWebsocketChangingType()const
+{
+	return websocketChangingType_;
+}
+
 std::string DescribeDcdnServiceResult::getChangingChargeType()const
 {
 	return changingChargeType_;
@@ -71,6 +82,11 @@ std::string DescribeDcdnServiceResult::getInstanceId()const
 	return instanceId_;
 }
 
+std::string DescribeDcdnServiceResult::getWebsocketType()const
+{
+	return websocketType_;
+}
+
 std::string DescribeDcdnServiceResult::getOpeningTime()const
 {
 	return openingTime_;
@@ -91,3 +107,8 @@ std::string DescribeDcdnServiceResult::getInternetChargeType()const
 	return internetChargeType_;
 }
 
+std::string DescribeDcdnServiceResult::getWebsocketChangingTime()const
+{
+	return websocketChangingTime_;
+}
+

dcdn/src/model/DescribeDcdnTopDomainsByFlowRequest.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/dcdn/model/DescribeDcdnTopDomainsByFlowRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnTopDomainsByFlowRequest;
+
+DescribeDcdnTopDomainsByFlowRequest::DescribeDcdnTopDomainsByFlowRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnTopDomainsByFlow")
+{}
+
+DescribeDcdnTopDomainsByFlowRequest::~DescribeDcdnTopDomainsByFlowRequest()
+{}
+
+long DescribeDcdnTopDomainsByFlowRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeDcdnTopDomainsByFlowRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::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 DescribeDcdnTopDomainsByFlowRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::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 DescribeDcdnTopDomainsByFlowRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getAoneId()const
+{
+	return aoneId_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setAoneId(const std::string& aoneId)
+{
+	aoneId_ = aoneId;
+	setParameter("AoneId", aoneId);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+long DescribeDcdnTopDomainsByFlowRequest::getLimit()const
+{
+	return limit_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setLimit(long limit)
+{
+	limit_ = limit;
+	setParameter("Limit", std::to_string(limit));
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeDcdnTopDomainsByFlowRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getPopProduct()const
+{
+	return popProduct_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setPopProduct(const std::string& popProduct)
+{
+	popProduct_ = popProduct;
+	setParameter("PopProduct", popProduct);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getMethod()const
+{
+	return method_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setMethod(const std::string& method)
+{
+	method_ = method;
+	setParameter("Method", method);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeDcdnTopDomainsByFlowRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeDcdnTopDomainsByFlowRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::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 DescribeDcdnTopDomainsByFlowRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeDcdnTopDomainsByFlowRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeDcdnTopDomainsByFlowRequest::getCategory()const
+{
+	return category_;
+}
+
+void DescribeDcdnTopDomainsByFlowRequest::setCategory(const std::string& category)
+{
+	category_ = category;
+	setParameter("Category", category);
+}
+

dcdn/src/model/DescribeDcdnTopDomainsByFlowResult.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/dcdn/model/DescribeDcdnTopDomainsByFlowResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnTopDomainsByFlowResult::DescribeDcdnTopDomainsByFlowResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnTopDomainsByFlowResult::DescribeDcdnTopDomainsByFlowResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnTopDomainsByFlowResult::~DescribeDcdnTopDomainsByFlowResult()
+{}
+
+void DescribeDcdnTopDomainsByFlowResult::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<DescribeDcdnTopDomainsByFlowResult::TopDomain> DescribeDcdnTopDomainsByFlowResult::getTopDomains()const
+{
+	return topDomains_;
+}
+
+std::string DescribeDcdnTopDomainsByFlowResult::getEndTime()const
+{
+	return endTime_;
+}
+
+long DescribeDcdnTopDomainsByFlowResult::getDomainOnlineCount()const
+{
+	return domainOnlineCount_;
+}
+
+std::string DescribeDcdnTopDomainsByFlowResult::getStartTime()const
+{
+	return startTime_;
+}
+
+long DescribeDcdnTopDomainsByFlowResult::getDomainCount()const
+{
+	return domainCount_;
+}
+

dcdn/src/model/DescribeDcdnUserDomainsResult.cc

@@ -74,6 +74,8 @@ void DescribeDcdnUserDomainsResult::parse(const std::string &payload)
 				sourcesObject.port = std::stoi(value["Port"].asString());
 			if(!value["Priority"].isNull())
 				sourcesObject.priority = value["Priority"].asString();
+			if(!value["Weight"].isNull())
+				sourcesObject.weight = value["Weight"].asString();
 			domainsObject.sources.push_back(sourcesObject);
 		}
 		domains_.push_back(domainsObject);

dcdn/src/model/DescribeDcdnUserQuotaRequest.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/dcdn/model/DescribeDcdnUserQuotaRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnUserQuotaRequest;
+
+DescribeDcdnUserQuotaRequest::DescribeDcdnUserQuotaRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnUserQuota")
+{}
+
+DescribeDcdnUserQuotaRequest::~DescribeDcdnUserQuotaRequest()
+{}
+
+std::string DescribeDcdnUserQuotaRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeDcdnUserQuotaRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+long DescribeDcdnUserQuotaRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnUserQuotaRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDcdnUserQuotaRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDcdnUserQuotaRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

dcdn/src/model/DescribeDcdnUserQuotaResult.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/dcdn/model/DescribeDcdnUserQuotaResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnUserQuotaResult::DescribeDcdnUserQuotaResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnUserQuotaResult::DescribeDcdnUserQuotaResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnUserQuotaResult::~DescribeDcdnUserQuotaResult()
+{}
+
+void DescribeDcdnUserQuotaResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["DomainQuota"].isNull())
+		domainQuota_ = std::stoi(value["DomainQuota"].asString());
+	if(!value["RefreshUrlQuota"].isNull())
+		refreshUrlQuota_ = std::stoi(value["RefreshUrlQuota"].asString());
+	if(!value["RefreshDirQuota"].isNull())
+		refreshDirQuota_ = std::stoi(value["RefreshDirQuota"].asString());
+	if(!value["RefreshUrlRemain"].isNull())
+		refreshUrlRemain_ = std::stoi(value["RefreshUrlRemain"].asString());
+	if(!value["RefreshDirRemain"].isNull())
+		refreshDirRemain_ = std::stoi(value["RefreshDirRemain"].asString());
+	if(!value["PreloadQuota"].isNull())
+		preloadQuota_ = std::stoi(value["PreloadQuota"].asString());
+	if(!value["PreloadRemain"].isNull())
+		preloadRemain_ = std::stoi(value["PreloadRemain"].asString());
+	if(!value["BlockQuota"].isNull())
+		blockQuota_ = std::stoi(value["BlockQuota"].asString());
+	if(!value["BlockRemain"].isNull())
+		blockRemain_ = std::stoi(value["BlockRemain"].asString());
+
+}
+
+int DescribeDcdnUserQuotaResult::getRefreshUrlQuota()const
+{
+	return refreshUrlQuota_;
+}
+
+int DescribeDcdnUserQuotaResult::getPreloadRemain()const
+{
+	return preloadRemain_;
+}
+
+int DescribeDcdnUserQuotaResult::getBlockRemain()const
+{
+	return blockRemain_;
+}
+
+int DescribeDcdnUserQuotaResult::getRefreshDirRemain()const
+{
+	return refreshDirRemain_;
+}
+
+int DescribeDcdnUserQuotaResult::getRefreshDirQuota()const
+{
+	return refreshDirQuota_;
+}
+
+int DescribeDcdnUserQuotaResult::getBlockQuota()const
+{
+	return blockQuota_;
+}
+
+int DescribeDcdnUserQuotaResult::getDomainQuota()const
+{
+	return domainQuota_;
+}
+
+int DescribeDcdnUserQuotaResult::getRefreshUrlRemain()const
+{
+	return refreshUrlRemain_;
+}
+
+int DescribeDcdnUserQuotaResult::getPreloadQuota()const
+{
+	return preloadQuota_;
+}
+

dcdn/src/model/DescribeDcdnUserResourcePackageResult.cc

@@ -56,6 +56,10 @@ void DescribeDcdnUserResourcePackageResult::parse(const std::string &payload)
 			resourcePackageInfosObject.instanceId = value["InstanceId"].asString();
 		if(!value["Status"].isNull())
 			resourcePackageInfosObject.status = value["Status"].asString();
+		if(!value["StartTime"].isNull())
+			resourcePackageInfosObject.startTime = value["StartTime"].asString();
+		if(!value["EndTime"].isNull())
+			resourcePackageInfosObject.endTime = value["EndTime"].asString();
 		resourcePackageInfos_.push_back(resourcePackageInfosObject);
 	}
 

dcdn/src/model/PreloadDcdnObjectCachesRequest.cc

@@ -25,6 +25,17 @@ PreloadDcdnObjectCachesRequest::PreloadDcdnObjectCachesRequest() :
 PreloadDcdnObjectCachesRequest::~PreloadDcdnObjectCachesRequest()
 {}
 
+std::string PreloadDcdnObjectCachesRequest::getArea()const
+{
+	return area_;
+}
+
+void PreloadDcdnObjectCachesRequest::setArea(const std::string& area)
+{
+	area_ = area;
+	setParameter("Area", area);
+}
+
 std::string PreloadDcdnObjectCachesRequest::getSecurityToken()const
 {
 	return securityToken_;