Add support cn-beijing service region.

CHANGELOG

@@ -1,3 +1,71 @@
+2020-09-09 Version: patch
+- Add support cn-beijing service region.
+- Add ai video cover interface,include submit and query.
+- Add dynamic image query interface.
+- Update SubmitMediaAuditJob support MediaAuditConfiguration to set ResourceType.
+
+2020-09-09 Version: patch
+- Release ChangeSky.
+
+2020-09-09 Version: patch
+- Release DetectChefCap.
+
+2020-09-09 Version: patch
+- Release DetectKneeKeypointXRay, DetectHipKeypointXRay, CalcCACS, RunCTRegistration, ClassifyFNF.
+
+2020-09-08 Version: patch
+- Supported backend interface for ICBU.
+
+2020-09-08 Version: patch
+- Add DescribeActiveOperationTask.
+- Add DescribeActiveOperationTaskCount.
+- Add DescribeActiveOperationTaskRegion.
+- Add DescribeActiveOperationTaskType.
+- Add ModifyActiveOperationTask.
+
+2020-09-08 Version: patch
+- Modify CreateAsyncPredict add new parameters.
+
+2020-09-07 Version: patch
+- Support parameter APIs.
+
+2020-09-07 Version: patch
+- Add describes devices API.
+
+2020-09-07 Version: patch
+- Add describes devices API.
+
+2020-09-07 Version: patch
+- Add describes devices API.
+
+2020-09-07 Version: patch
+- Add describes devices API.
+
+2020-09-07 Version: patch
+- Add describes devices API.
+
+2020-09-05 Version: patch
+- Add describes devices API.
+
+2020-09-04 Version: patch
+- Sync cdn APIs.
+
+2020-09-04 Version: patch
+- Update Scdn API.
+
+2020-09-04 Version: patch
+- Update domain API.
+
+2020-09-04 Version: patch
+- Add GetImageQuality API.
+- Add more info as parameters to Images related APIs.
+
+2020-09-03 Version: 1.36.632
+- DescribeCameraStatistics add parameters.
+
+2020-09-02 Version: 1.36.631
+- Support sg for ml region.
+
 2020-09-02 Version: 1.36.630
 - ChatApp second version.
 - Support new message fomat.

VERSION

@@ -1 +1 @@
-1.36.630
+1.36.632

cdn/CMakeLists.txt

@@ -109,6 +109,8 @@ set(cdn_public_header_model
 	include/alibabacloud/cdn/model/DescribeCdnUserBillTypeResult.h
 	include/alibabacloud/cdn/model/DescribeCdnUserConfigsRequest.h
 	include/alibabacloud/cdn/model/DescribeCdnUserConfigsResult.h
+	include/alibabacloud/cdn/model/DescribeCdnUserDomainsByFuncRequest.h
+	include/alibabacloud/cdn/model/DescribeCdnUserDomainsByFuncResult.h
 	include/alibabacloud/cdn/model/DescribeCdnUserQuotaRequest.h
 	include/alibabacloud/cdn/model/DescribeCdnUserQuotaResult.h
 	include/alibabacloud/cdn/model/DescribeCdnUserResourcePackageRequest.h
@@ -397,8 +399,6 @@ set(cdn_public_header_model
 	include/alibabacloud/cdn/model/SetUserGreenManagerConfigResult.h
 	include/alibabacloud/cdn/model/SetVideoSeekConfigRequest.h
 	include/alibabacloud/cdn/model/SetVideoSeekConfigResult.h
-	include/alibabacloud/cdn/model/SetWafConfigRequest.h
-	include/alibabacloud/cdn/model/SetWafConfigResult.h
 	include/alibabacloud/cdn/model/SetWaitingRoomConfigRequest.h
 	include/alibabacloud/cdn/model/SetWaitingRoomConfigResult.h
 	include/alibabacloud/cdn/model/StartCdnDomainRequest.h
@@ -506,6 +506,8 @@ set(cdn_src
 	src/model/DescribeCdnUserBillTypeResult.cc
 	src/model/DescribeCdnUserConfigsRequest.cc
 	src/model/DescribeCdnUserConfigsResult.cc
+	src/model/DescribeCdnUserDomainsByFuncRequest.cc
+	src/model/DescribeCdnUserDomainsByFuncResult.cc
 	src/model/DescribeCdnUserQuotaRequest.cc
 	src/model/DescribeCdnUserQuotaResult.cc
 	src/model/DescribeCdnUserResourcePackageRequest.cc
@@ -794,8 +796,6 @@ set(cdn_src
 	src/model/SetUserGreenManagerConfigResult.cc
 	src/model/SetVideoSeekConfigRequest.cc
 	src/model/SetVideoSeekConfigResult.cc
-	src/model/SetWafConfigRequest.cc
-	src/model/SetWafConfigResult.cc
 	src/model/SetWaitingRoomConfigRequest.cc
 	src/model/SetWaitingRoomConfigResult.cc
 	src/model/StartCdnDomainRequest.cc

cdn/include/alibabacloud/cdn/CdnClient.h

@@ -110,6 +110,8 @@
 #include "model/DescribeCdnUserBillTypeResult.h"
 #include "model/DescribeCdnUserConfigsRequest.h"
 #include "model/DescribeCdnUserConfigsResult.h"
+#include "model/DescribeCdnUserDomainsByFuncRequest.h"
+#include "model/DescribeCdnUserDomainsByFuncResult.h"
 #include "model/DescribeCdnUserQuotaRequest.h"
 #include "model/DescribeCdnUserQuotaResult.h"
 #include "model/DescribeCdnUserResourcePackageRequest.h"
@@ -398,8 +400,6 @@
 #include "model/SetUserGreenManagerConfigResult.h"
 #include "model/SetVideoSeekConfigRequest.h"
 #include "model/SetVideoSeekConfigResult.h"
-#include "model/SetWafConfigRequest.h"
-#include "model/SetWafConfigResult.h"
 #include "model/SetWaitingRoomConfigRequest.h"
 #include "model/SetWaitingRoomConfigResult.h"
 #include "model/StartCdnDomainRequest.h"
@@ -557,6 +557,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeCdnUserConfigsResult> DescribeCdnUserConfigsOutcome;
 			typedef std::future<DescribeCdnUserConfigsOutcome> DescribeCdnUserConfigsOutcomeCallable;
 			typedef std::function<void(const CdnClient*, const Model::DescribeCdnUserConfigsRequest&, const DescribeCdnUserConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCdnUserConfigsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeCdnUserDomainsByFuncResult> DescribeCdnUserDomainsByFuncOutcome;
+			typedef std::future<DescribeCdnUserDomainsByFuncOutcome> DescribeCdnUserDomainsByFuncOutcomeCallable;
+			typedef std::function<void(const CdnClient*, const Model::DescribeCdnUserDomainsByFuncRequest&, const DescribeCdnUserDomainsByFuncOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCdnUserDomainsByFuncAsyncHandler;
 			typedef Outcome<Error, Model::DescribeCdnUserQuotaResult> DescribeCdnUserQuotaOutcome;
 			typedef std::future<DescribeCdnUserQuotaOutcome> DescribeCdnUserQuotaOutcomeCallable;
 			typedef std::function<void(const CdnClient*, const Model::DescribeCdnUserQuotaRequest&, const DescribeCdnUserQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCdnUserQuotaAsyncHandler;
@@ -989,9 +992,6 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::SetVideoSeekConfigResult> SetVideoSeekConfigOutcome;
 			typedef std::future<SetVideoSeekConfigOutcome> SetVideoSeekConfigOutcomeCallable;
 			typedef std::function<void(const CdnClient*, const Model::SetVideoSeekConfigRequest&, const SetVideoSeekConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetVideoSeekConfigAsyncHandler;
-			typedef Outcome<Error, Model::SetWafConfigResult> SetWafConfigOutcome;
-			typedef std::future<SetWafConfigOutcome> SetWafConfigOutcomeCallable;
-			typedef std::function<void(const CdnClient*, const Model::SetWafConfigRequest&, const SetWafConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetWafConfigAsyncHandler;
 			typedef Outcome<Error, Model::SetWaitingRoomConfigResult> SetWaitingRoomConfigOutcome;
 			typedef std::future<SetWaitingRoomConfigOutcome> SetWaitingRoomConfigOutcomeCallable;
 			typedef std::function<void(const CdnClient*, const Model::SetWaitingRoomConfigRequest&, const SetWaitingRoomConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetWaitingRoomConfigAsyncHandler;
@@ -1153,6 +1153,9 @@ namespace AlibabaCloud
 			DescribeCdnUserConfigsOutcome describeCdnUserConfigs(const Model::DescribeCdnUserConfigsRequest &request)const;
 			void describeCdnUserConfigsAsync(const Model::DescribeCdnUserConfigsRequest& request, const DescribeCdnUserConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeCdnUserConfigsOutcomeCallable describeCdnUserConfigsCallable(const Model::DescribeCdnUserConfigsRequest& request) const;
+			DescribeCdnUserDomainsByFuncOutcome describeCdnUserDomainsByFunc(const Model::DescribeCdnUserDomainsByFuncRequest &request)const;
+			void describeCdnUserDomainsByFuncAsync(const Model::DescribeCdnUserDomainsByFuncRequest& request, const DescribeCdnUserDomainsByFuncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeCdnUserDomainsByFuncOutcomeCallable describeCdnUserDomainsByFuncCallable(const Model::DescribeCdnUserDomainsByFuncRequest& request) const;
 			DescribeCdnUserQuotaOutcome describeCdnUserQuota(const Model::DescribeCdnUserQuotaRequest &request)const;
 			void describeCdnUserQuotaAsync(const Model::DescribeCdnUserQuotaRequest& request, const DescribeCdnUserQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeCdnUserQuotaOutcomeCallable describeCdnUserQuotaCallable(const Model::DescribeCdnUserQuotaRequest& request) const;
@@ -1585,9 +1588,6 @@ namespace AlibabaCloud
 			SetVideoSeekConfigOutcome setVideoSeekConfig(const Model::SetVideoSeekConfigRequest &request)const;
 			void setVideoSeekConfigAsync(const Model::SetVideoSeekConfigRequest& request, const SetVideoSeekConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetVideoSeekConfigOutcomeCallable setVideoSeekConfigCallable(const Model::SetVideoSeekConfigRequest& request) const;
-			SetWafConfigOutcome setWafConfig(const Model::SetWafConfigRequest &request)const;
-			void setWafConfigAsync(const Model::SetWafConfigRequest& request, const SetWafConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
-			SetWafConfigOutcomeCallable setWafConfigCallable(const Model::SetWafConfigRequest& request) const;
 			SetWaitingRoomConfigOutcome setWaitingRoomConfig(const Model::SetWaitingRoomConfigRequest &request)const;
 			void setWaitingRoomConfigAsync(const Model::SetWaitingRoomConfigRequest& request, const SetWaitingRoomConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetWaitingRoomConfigOutcomeCallable setWaitingRoomConfigCallable(const Model::SetWaitingRoomConfigRequest& request) const;

cdn/include/alibabacloud/cdn/model/DescribeCdnUserDomainsByFuncRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CDN_MODEL_DESCRIBECDNUSERDOMAINSBYFUNCREQUEST_H_
+#define ALIBABACLOUD_CDN_MODEL_DESCRIBECDNUSERDOMAINSBYFUNCREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/cdn/CdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CDN_EXPORT DescribeCdnUserDomainsByFuncRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeCdnUserDomainsByFuncRequest();
+				~DescribeCdnUserDomainsByFuncRequest();
+
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getFuncId()const;
+				void setFuncId(int funcId);
+
+            private:
+				int pageNumber_;
+				std::string resourceGroupId_;
+				int pageSize_;
+				long ownerId_;
+				int funcId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CDN_MODEL_DESCRIBECDNUSERDOMAINSBYFUNCREQUEST_H_

cdn/include/alibabacloud/cdn/model/DescribeCdnUserDomainsByFuncResult.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_CDN_MODEL_DESCRIBECDNUSERDOMAINSBYFUNCRESULT_H_
+#define ALIBABACLOUD_CDN_MODEL_DESCRIBECDNUSERDOMAINSBYFUNCRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cdn/CdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CDN_EXPORT DescribeCdnUserDomainsByFuncResult : public ServiceResult
+			{
+			public:
+				struct PageData
+				{
+					struct Source
+					{
+						std::string type;
+						std::string content;
+						std::string priority;
+						int port;
+						std::string weight;
+					};
+					std::string description;
+					std::string sslProtocol;
+					std::string resourceGroupId;
+					std::string domainName;
+					std::string gmtModified;
+					std::string cdnType;
+					std::string gmtCreated;
+					std::vector<PageData::Source> sources;
+					std::string cname;
+					std::string domainStatus;
+					std::string sandbox;
+				};
+
+
+				DescribeCdnUserDomainsByFuncResult();
+				explicit DescribeCdnUserDomainsByFuncResult(const std::string &payload);
+				~DescribeCdnUserDomainsByFuncResult();
+				std::vector<PageData> getDomains()const;
+				long getTotalCount()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<PageData> domains_;
+				long totalCount_;
+				long pageSize_;
+				long pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CDN_MODEL_DESCRIBECDNUSERDOMAINSBYFUNCRESULT_H_

cdn/src/CdnClient.cc

@@ -1635,6 +1635,42 @@ CdnClient::DescribeCdnUserConfigsOutcomeCallable CdnClient::describeCdnUserConfi
 	return task->get_future();
 }
 
+CdnClient::DescribeCdnUserDomainsByFuncOutcome CdnClient::describeCdnUserDomainsByFunc(const DescribeCdnUserDomainsByFuncRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeCdnUserDomainsByFuncOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeCdnUserDomainsByFuncOutcome(DescribeCdnUserDomainsByFuncResult(outcome.result()));
+	else
+		return DescribeCdnUserDomainsByFuncOutcome(outcome.error());
+}
+
+void CdnClient::describeCdnUserDomainsByFuncAsync(const DescribeCdnUserDomainsByFuncRequest& request, const DescribeCdnUserDomainsByFuncAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeCdnUserDomainsByFunc(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CdnClient::DescribeCdnUserDomainsByFuncOutcomeCallable CdnClient::describeCdnUserDomainsByFuncCallable(const DescribeCdnUserDomainsByFuncRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeCdnUserDomainsByFuncOutcome()>>(
+			[this, request]()
+			{
+			return this->describeCdnUserDomainsByFunc(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CdnClient::DescribeCdnUserQuotaOutcome CdnClient::describeCdnUserQuota(const DescribeCdnUserQuotaRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6819,42 +6855,6 @@ CdnClient::SetVideoSeekConfigOutcomeCallable CdnClient::setVideoSeekConfigCallab
 	return task->get_future();
 }
 
-CdnClient::SetWafConfigOutcome CdnClient::setWafConfig(const SetWafConfigRequest &request) const
-{
-	auto endpointOutcome = endpointProvider_->getEndpoint();
-	if (!endpointOutcome.isSuccess())
-		return SetWafConfigOutcome(endpointOutcome.error());
-
-	auto outcome = makeRequest(endpointOutcome.result(), request);
-
-	if (outcome.isSuccess())
-		return SetWafConfigOutcome(SetWafConfigResult(outcome.result()));
-	else
-		return SetWafConfigOutcome(outcome.error());
-}
-
-void CdnClient::setWafConfigAsync(const SetWafConfigRequest& request, const SetWafConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
-{
-	auto fn = [this, request, handler, context]()
-	{
-		handler(this, request, setWafConfig(request), context);
-	};
-
-	asyncExecute(new Runnable(fn));
-}
-
-CdnClient::SetWafConfigOutcomeCallable CdnClient::setWafConfigCallable(const SetWafConfigRequest &request) const
-{
-	auto task = std::make_shared<std::packaged_task<SetWafConfigOutcome()>>(
-			[this, request]()
-			{
-			return this->setWafConfig(request);
-			});
-
-	asyncExecute(new Runnable([task]() { (*task)(); }));
-	return task->get_future();
-}
-
 CdnClient::SetWaitingRoomConfigOutcome CdnClient::setWaitingRoomConfig(const SetWaitingRoomConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

cdn/src/model/DescribeCdnUserDomainsByFuncRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/cdn/model/DescribeCdnUserDomainsByFuncRequest.h>
+
+using AlibabaCloud::Cdn::Model::DescribeCdnUserDomainsByFuncRequest;
+
+DescribeCdnUserDomainsByFuncRequest::DescribeCdnUserDomainsByFuncRequest() :
+	RpcServiceRequest("cdn", "2018-05-10", "DescribeCdnUserDomainsByFunc")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeCdnUserDomainsByFuncRequest::~DescribeCdnUserDomainsByFuncRequest()
+{}
+
+int DescribeCdnUserDomainsByFuncRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeCdnUserDomainsByFuncRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeCdnUserDomainsByFuncRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void DescribeCdnUserDomainsByFuncRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
+int DescribeCdnUserDomainsByFuncRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeCdnUserDomainsByFuncRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+long DescribeCdnUserDomainsByFuncRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeCdnUserDomainsByFuncRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+int DescribeCdnUserDomainsByFuncRequest::getFuncId()const
+{
+	return funcId_;
+}
+
+void DescribeCdnUserDomainsByFuncRequest::setFuncId(int funcId)
+{
+	funcId_ = funcId;
+	setParameter("FuncId", std::to_string(funcId));
+}
+

cdn/src/model/DescribeCdnUserDomainsByFuncResult.cc

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/cdn/model/DescribeCdnUserDomainsByFuncResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cdn;
+using namespace AlibabaCloud::Cdn::Model;
+
+DescribeCdnUserDomainsByFuncResult::DescribeCdnUserDomainsByFuncResult() :
+	ServiceResult()
+{}
+
+DescribeCdnUserDomainsByFuncResult::DescribeCdnUserDomainsByFuncResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeCdnUserDomainsByFuncResult::~DescribeCdnUserDomainsByFuncResult()
+{}
+
+void DescribeCdnUserDomainsByFuncResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDomainsNode = value["Domains"]["PageData"];
+	for (auto valueDomainsPageData : allDomainsNode)
+	{
+		PageData domainsObject;
+		if(!valueDomainsPageData["DomainName"].isNull())
+			domainsObject.domainName = valueDomainsPageData["DomainName"].asString();
+		if(!valueDomainsPageData["Cname"].isNull())
+			domainsObject.cname = valueDomainsPageData["Cname"].asString();
+		if(!valueDomainsPageData["CdnType"].isNull())
+			domainsObject.cdnType = valueDomainsPageData["CdnType"].asString();
+		if(!valueDomainsPageData["DomainStatus"].isNull())
+			domainsObject.domainStatus = valueDomainsPageData["DomainStatus"].asString();
+		if(!valueDomainsPageData["GmtCreated"].isNull())
+			domainsObject.gmtCreated = valueDomainsPageData["GmtCreated"].asString();
+		if(!valueDomainsPageData["GmtModified"].isNull())
+			domainsObject.gmtModified = valueDomainsPageData["GmtModified"].asString();
+		if(!valueDomainsPageData["Description"].isNull())
+			domainsObject.description = valueDomainsPageData["Description"].asString();
+		if(!valueDomainsPageData["SslProtocol"].isNull())
+			domainsObject.sslProtocol = valueDomainsPageData["SslProtocol"].asString();
+		if(!valueDomainsPageData["ResourceGroupId"].isNull())
+			domainsObject.resourceGroupId = valueDomainsPageData["ResourceGroupId"].asString();
+		if(!valueDomainsPageData["Sandbox"].isNull())
+			domainsObject.sandbox = valueDomainsPageData["Sandbox"].asString();
+		auto allSourcesNode = allDomainsNode["Sources"]["Source"];
+		for (auto allDomainsNodeSourcesSource : allSourcesNode)
+		{
+			PageData::Source sourcesObject;
+			if(!allDomainsNodeSourcesSource["Type"].isNull())
+				sourcesObject.type = allDomainsNodeSourcesSource["Type"].asString();
+			if(!allDomainsNodeSourcesSource["Content"].isNull())
+				sourcesObject.content = allDomainsNodeSourcesSource["Content"].asString();
+			if(!allDomainsNodeSourcesSource["Port"].isNull())
+				sourcesObject.port = std::stoi(allDomainsNodeSourcesSource["Port"].asString());
+			if(!allDomainsNodeSourcesSource["Priority"].isNull())
+				sourcesObject.priority = allDomainsNodeSourcesSource["Priority"].asString();
+			if(!allDomainsNodeSourcesSource["Weight"].isNull())
+				sourcesObject.weight = allDomainsNodeSourcesSource["Weight"].asString();
+			domainsObject.sources.push_back(sourcesObject);
+		}
+		domains_.push_back(domainsObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stol(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stol(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+
+}
+
+std::vector<DescribeCdnUserDomainsByFuncResult::PageData> DescribeCdnUserDomainsByFuncResult::getDomains()const
+{
+	return domains_;
+}
+
+long DescribeCdnUserDomainsByFuncResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+long DescribeCdnUserDomainsByFuncResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+long DescribeCdnUserDomainsByFuncResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

cdn/src/model/SetWafConfigRequest.cc

@@ -1,73 +0,0 @@
-/*
- * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT 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/cdn/model/SetWafConfigRequest.h>
-
-using AlibabaCloud::Cdn::Model::SetWafConfigRequest;
-
-SetWafConfigRequest::SetWafConfigRequest() :
-	RpcServiceRequest("cdn", "2018-05-10", "SetWafConfig")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-SetWafConfigRequest::~SetWafConfigRequest()
-{}
-
-std::string SetWafConfigRequest::getEnable()const
-{
-	return enable_;
-}
-
-void SetWafConfigRequest::setEnable(const std::string& enable)
-{
-	enable_ = enable;
-	setParameter("Enable", enable);
-}
-
-std::string SetWafConfigRequest::getDomainName()const
-{
-	return domainName_;
-}
-
-void SetWafConfigRequest::setDomainName(const std::string& domainName)
-{
-	domainName_ = domainName;
-	setParameter("DomainName", domainName);
-}
-
-long SetWafConfigRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void SetWafConfigRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
-}
-
-long SetWafConfigRequest::getConfigId()const
-{
-	return configId_;
-}
-
-void SetWafConfigRequest::setConfigId(long configId)
-{
-	configId_ = configId;
-	setParameter("ConfigId", std::to_string(configId));
-}
-

dcdn/CMakeLists.txt

@@ -43,10 +43,18 @@ set(dcdn_public_header_model
 	include/alibabacloud/dcdn/model/DeleteDcdnIpaSpecificConfigResult.h
 	include/alibabacloud/dcdn/model/DeleteDcdnSpecificConfigRequest.h
 	include/alibabacloud/dcdn/model/DeleteDcdnSpecificConfigResult.h
+	include/alibabacloud/dcdn/model/DeleteDcdnSpecificStagingConfigRequest.h
+	include/alibabacloud/dcdn/model/DeleteDcdnSpecificStagingConfigResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnBgpBpsDataRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnBgpBpsDataResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnBgpTrafficDataRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnBgpTrafficDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnCertificateDetailRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnCertificateDetailResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnCertificateListRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnCertificateListResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnConfigOfVersionRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnConfigOfVersionResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainBpsDataRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainBpsDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainByCertificateRequest.h
@@ -71,6 +79,8 @@ set(dcdn_public_header_model
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainIspDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainLogRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainLogResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainMultiUsageDataRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainMultiUsageDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainOriginBpsDataRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainOriginBpsDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainOriginTrafficDataRequest.h
@@ -93,10 +103,14 @@ set(dcdn_public_header_model
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeReqHitRateDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeSrcBpsDataRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeSrcBpsDataResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeSrcHttpCodeDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeSrcTrafficDataRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeSrcTrafficDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRegionDataRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainRegionDataResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainStagingConfigRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnDomainStagingConfigResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainTopReferVisitRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainTopReferVisitResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainTopUrlVisitRequest.h
@@ -113,6 +127,8 @@ set(dcdn_public_header_model
 	include/alibabacloud/dcdn/model/DescribeDcdnDomainWebsocketTrafficDataResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnHttpsDomainListRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnHttpsDomainListResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnIpInfoRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnIpInfoResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnIpaDomainConfigsRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnIpaDomainConfigsResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnIpaDomainDetailRequest.h
@@ -127,14 +143,22 @@ set(dcdn_public_header_model
 	include/alibabacloud/dcdn/model/DescribeDcdnRefreshTasksResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnServiceRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnServiceResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnStagingIpRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnStagingIpResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnTagResourcesRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnTagResourcesResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnTopDomainsByFlowRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnTopDomainsByFlowResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnUserBillTypeRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnUserBillTypeResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnUserDomainsRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnUserDomainsResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnUserQuotaRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnUserQuotaResult.h
 	include/alibabacloud/dcdn/model/DescribeDcdnUserResourcePackageRequest.h
 	include/alibabacloud/dcdn/model/DescribeDcdnUserResourcePackageResult.h
+	include/alibabacloud/dcdn/model/DescribeDcdnUserTagsRequest.h
+	include/alibabacloud/dcdn/model/DescribeDcdnUserTagsResult.h
 	include/alibabacloud/dcdn/model/DescribeUserDcdnIpaStatusRequest.h
 	include/alibabacloud/dcdn/model/DescribeUserDcdnIpaStatusResult.h
 	include/alibabacloud/dcdn/model/DescribeUserDcdnStatusRequest.h
@@ -143,10 +167,18 @@ set(dcdn_public_header_model
 	include/alibabacloud/dcdn/model/ModifyDCdnDomainSchdmByPropertyResult.h
 	include/alibabacloud/dcdn/model/PreloadDcdnObjectCachesRequest.h
 	include/alibabacloud/dcdn/model/PreloadDcdnObjectCachesResult.h
+	include/alibabacloud/dcdn/model/PublishDcdnStagingConfigToProductionRequest.h
+	include/alibabacloud/dcdn/model/PublishDcdnStagingConfigToProductionResult.h
 	include/alibabacloud/dcdn/model/RefreshDcdnObjectCachesRequest.h
 	include/alibabacloud/dcdn/model/RefreshDcdnObjectCachesResult.h
+	include/alibabacloud/dcdn/model/RollbackDcdnStagingConfigRequest.h
+	include/alibabacloud/dcdn/model/RollbackDcdnStagingConfigResult.h
+	include/alibabacloud/dcdn/model/SetDcdnConfigOfVersionRequest.h
+	include/alibabacloud/dcdn/model/SetDcdnConfigOfVersionResult.h
 	include/alibabacloud/dcdn/model/SetDcdnDomainCertificateRequest.h
 	include/alibabacloud/dcdn/model/SetDcdnDomainCertificateResult.h
+	include/alibabacloud/dcdn/model/SetDcdnDomainStagingConfigRequest.h
+	include/alibabacloud/dcdn/model/SetDcdnDomainStagingConfigResult.h
 	include/alibabacloud/dcdn/model/StartDcdnDomainRequest.h
 	include/alibabacloud/dcdn/model/StartDcdnDomainResult.h
 	include/alibabacloud/dcdn/model/StartDcdnIpaDomainRequest.h
@@ -155,6 +187,10 @@ set(dcdn_public_header_model
 	include/alibabacloud/dcdn/model/StopDcdnDomainResult.h
 	include/alibabacloud/dcdn/model/StopDcdnIpaDomainRequest.h
 	include/alibabacloud/dcdn/model/StopDcdnIpaDomainResult.h
+	include/alibabacloud/dcdn/model/TagDcdnResourcesRequest.h
+	include/alibabacloud/dcdn/model/TagDcdnResourcesResult.h
+	include/alibabacloud/dcdn/model/UntagDcdnResourcesRequest.h
+	include/alibabacloud/dcdn/model/UntagDcdnResourcesResult.h
 	include/alibabacloud/dcdn/model/UpdateDcdnDomainRequest.h
 	include/alibabacloud/dcdn/model/UpdateDcdnDomainResult.h
 	include/alibabacloud/dcdn/model/UpdateDcdnIpaDomainRequest.h
@@ -184,10 +220,18 @@ set(dcdn_src
 	src/model/DeleteDcdnIpaSpecificConfigResult.cc
 	src/model/DeleteDcdnSpecificConfigRequest.cc
 	src/model/DeleteDcdnSpecificConfigResult.cc
+	src/model/DeleteDcdnSpecificStagingConfigRequest.cc
+	src/model/DeleteDcdnSpecificStagingConfigResult.cc
+	src/model/DescribeDcdnBgpBpsDataRequest.cc
+	src/model/DescribeDcdnBgpBpsDataResult.cc
+	src/model/DescribeDcdnBgpTrafficDataRequest.cc
+	src/model/DescribeDcdnBgpTrafficDataResult.cc
 	src/model/DescribeDcdnCertificateDetailRequest.cc
 	src/model/DescribeDcdnCertificateDetailResult.cc
 	src/model/DescribeDcdnCertificateListRequest.cc
 	src/model/DescribeDcdnCertificateListResult.cc
+	src/model/DescribeDcdnConfigOfVersionRequest.cc
+	src/model/DescribeDcdnConfigOfVersionResult.cc
 	src/model/DescribeDcdnDomainBpsDataRequest.cc
 	src/model/DescribeDcdnDomainBpsDataResult.cc
 	src/model/DescribeDcdnDomainByCertificateRequest.cc
@@ -212,6 +256,8 @@ set(dcdn_src
 	src/model/DescribeDcdnDomainIspDataResult.cc
 	src/model/DescribeDcdnDomainLogRequest.cc
 	src/model/DescribeDcdnDomainLogResult.cc
+	src/model/DescribeDcdnDomainMultiUsageDataRequest.cc
+	src/model/DescribeDcdnDomainMultiUsageDataResult.cc
 	src/model/DescribeDcdnDomainOriginBpsDataRequest.cc
 	src/model/DescribeDcdnDomainOriginBpsDataResult.cc
 	src/model/DescribeDcdnDomainOriginTrafficDataRequest.cc
@@ -234,10 +280,14 @@ set(dcdn_src
 	src/model/DescribeDcdnDomainRealTimeReqHitRateDataResult.cc
 	src/model/DescribeDcdnDomainRealTimeSrcBpsDataRequest.cc
 	src/model/DescribeDcdnDomainRealTimeSrcBpsDataResult.cc
+	src/model/DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest.cc
+	src/model/DescribeDcdnDomainRealTimeSrcHttpCodeDataResult.cc
 	src/model/DescribeDcdnDomainRealTimeSrcTrafficDataRequest.cc
 	src/model/DescribeDcdnDomainRealTimeSrcTrafficDataResult.cc
 	src/model/DescribeDcdnDomainRegionDataRequest.cc
 	src/model/DescribeDcdnDomainRegionDataResult.cc
+	src/model/DescribeDcdnDomainStagingConfigRequest.cc
+	src/model/DescribeDcdnDomainStagingConfigResult.cc
 	src/model/DescribeDcdnDomainTopReferVisitRequest.cc
 	src/model/DescribeDcdnDomainTopReferVisitResult.cc
 	src/model/DescribeDcdnDomainTopUrlVisitRequest.cc
@@ -254,6 +304,8 @@ set(dcdn_src
 	src/model/DescribeDcdnDomainWebsocketTrafficDataResult.cc
 	src/model/DescribeDcdnHttpsDomainListRequest.cc
 	src/model/DescribeDcdnHttpsDomainListResult.cc
+	src/model/DescribeDcdnIpInfoRequest.cc
+	src/model/DescribeDcdnIpInfoResult.cc
 	src/model/DescribeDcdnIpaDomainConfigsRequest.cc
 	src/model/DescribeDcdnIpaDomainConfigsResult.cc
 	src/model/DescribeDcdnIpaDomainDetailRequest.cc
@@ -268,14 +320,22 @@ set(dcdn_src
 	src/model/DescribeDcdnRefreshTasksResult.cc
 	src/model/DescribeDcdnServiceRequest.cc
 	src/model/DescribeDcdnServiceResult.cc
+	src/model/DescribeDcdnStagingIpRequest.cc
+	src/model/DescribeDcdnStagingIpResult.cc
+	src/model/DescribeDcdnTagResourcesRequest.cc
+	src/model/DescribeDcdnTagResourcesResult.cc
 	src/model/DescribeDcdnTopDomainsByFlowRequest.cc
 	src/model/DescribeDcdnTopDomainsByFlowResult.cc
+	src/model/DescribeDcdnUserBillTypeRequest.cc
+	src/model/DescribeDcdnUserBillTypeResult.cc
 	src/model/DescribeDcdnUserDomainsRequest.cc
 	src/model/DescribeDcdnUserDomainsResult.cc
 	src/model/DescribeDcdnUserQuotaRequest.cc
 	src/model/DescribeDcdnUserQuotaResult.cc
 	src/model/DescribeDcdnUserResourcePackageRequest.cc
 	src/model/DescribeDcdnUserResourcePackageResult.cc
+	src/model/DescribeDcdnUserTagsRequest.cc
+	src/model/DescribeDcdnUserTagsResult.cc
 	src/model/DescribeUserDcdnIpaStatusRequest.cc
 	src/model/DescribeUserDcdnIpaStatusResult.cc
 	src/model/DescribeUserDcdnStatusRequest.cc
@@ -284,10 +344,18 @@ set(dcdn_src
 	src/model/ModifyDCdnDomainSchdmByPropertyResult.cc
 	src/model/PreloadDcdnObjectCachesRequest.cc
 	src/model/PreloadDcdnObjectCachesResult.cc
+	src/model/PublishDcdnStagingConfigToProductionRequest.cc
+	src/model/PublishDcdnStagingConfigToProductionResult.cc
 	src/model/RefreshDcdnObjectCachesRequest.cc
 	src/model/RefreshDcdnObjectCachesResult.cc
+	src/model/RollbackDcdnStagingConfigRequest.cc
+	src/model/RollbackDcdnStagingConfigResult.cc
+	src/model/SetDcdnConfigOfVersionRequest.cc
+	src/model/SetDcdnConfigOfVersionResult.cc
 	src/model/SetDcdnDomainCertificateRequest.cc
 	src/model/SetDcdnDomainCertificateResult.cc
+	src/model/SetDcdnDomainStagingConfigRequest.cc
+	src/model/SetDcdnDomainStagingConfigResult.cc
 	src/model/StartDcdnDomainRequest.cc
 	src/model/StartDcdnDomainResult.cc
 	src/model/StartDcdnIpaDomainRequest.cc
@@ -296,6 +364,10 @@ set(dcdn_src
 	src/model/StopDcdnDomainResult.cc
 	src/model/StopDcdnIpaDomainRequest.cc
 	src/model/StopDcdnIpaDomainResult.cc
+	src/model/TagDcdnResourcesRequest.cc
+	src/model/TagDcdnResourcesResult.cc
+	src/model/UntagDcdnResourcesRequest.cc
+	src/model/UntagDcdnResourcesResult.cc
 	src/model/UpdateDcdnDomainRequest.cc
 	src/model/UpdateDcdnDomainResult.cc
 	src/model/UpdateDcdnIpaDomainRequest.cc

dcdn/include/alibabacloud/dcdn/DcdnClient.h

@@ -44,10 +44,18 @@
 #include "model/DeleteDcdnIpaSpecificConfigResult.h"
 #include "model/DeleteDcdnSpecificConfigRequest.h"
 #include "model/DeleteDcdnSpecificConfigResult.h"
+#include "model/DeleteDcdnSpecificStagingConfigRequest.h"
+#include "model/DeleteDcdnSpecificStagingConfigResult.h"
+#include "model/DescribeDcdnBgpBpsDataRequest.h"
+#include "model/DescribeDcdnBgpBpsDataResult.h"
+#include "model/DescribeDcdnBgpTrafficDataRequest.h"
+#include "model/DescribeDcdnBgpTrafficDataResult.h"
 #include "model/DescribeDcdnCertificateDetailRequest.h"
 #include "model/DescribeDcdnCertificateDetailResult.h"
 #include "model/DescribeDcdnCertificateListRequest.h"
 #include "model/DescribeDcdnCertificateListResult.h"
+#include "model/DescribeDcdnConfigOfVersionRequest.h"
+#include "model/DescribeDcdnConfigOfVersionResult.h"
 #include "model/DescribeDcdnDomainBpsDataRequest.h"
 #include "model/DescribeDcdnDomainBpsDataResult.h"
 #include "model/DescribeDcdnDomainByCertificateRequest.h"
@@ -72,6 +80,8 @@
 #include "model/DescribeDcdnDomainIspDataResult.h"
 #include "model/DescribeDcdnDomainLogRequest.h"
 #include "model/DescribeDcdnDomainLogResult.h"
+#include "model/DescribeDcdnDomainMultiUsageDataRequest.h"
+#include "model/DescribeDcdnDomainMultiUsageDataResult.h"
 #include "model/DescribeDcdnDomainOriginBpsDataRequest.h"
 #include "model/DescribeDcdnDomainOriginBpsDataResult.h"
 #include "model/DescribeDcdnDomainOriginTrafficDataRequest.h"
@@ -94,10 +104,14 @@
 #include "model/DescribeDcdnDomainRealTimeReqHitRateDataResult.h"
 #include "model/DescribeDcdnDomainRealTimeSrcBpsDataRequest.h"
 #include "model/DescribeDcdnDomainRealTimeSrcBpsDataResult.h"
+#include "model/DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest.h"
+#include "model/DescribeDcdnDomainRealTimeSrcHttpCodeDataResult.h"
 #include "model/DescribeDcdnDomainRealTimeSrcTrafficDataRequest.h"
 #include "model/DescribeDcdnDomainRealTimeSrcTrafficDataResult.h"
 #include "model/DescribeDcdnDomainRegionDataRequest.h"
 #include "model/DescribeDcdnDomainRegionDataResult.h"
+#include "model/DescribeDcdnDomainStagingConfigRequest.h"
+#include "model/DescribeDcdnDomainStagingConfigResult.h"
 #include "model/DescribeDcdnDomainTopReferVisitRequest.h"
 #include "model/DescribeDcdnDomainTopReferVisitResult.h"
 #include "model/DescribeDcdnDomainTopUrlVisitRequest.h"
@@ -114,6 +128,8 @@
 #include "model/DescribeDcdnDomainWebsocketTrafficDataResult.h"
 #include "model/DescribeDcdnHttpsDomainListRequest.h"
 #include "model/DescribeDcdnHttpsDomainListResult.h"
+#include "model/DescribeDcdnIpInfoRequest.h"
+#include "model/DescribeDcdnIpInfoResult.h"
 #include "model/DescribeDcdnIpaDomainConfigsRequest.h"
 #include "model/DescribeDcdnIpaDomainConfigsResult.h"
 #include "model/DescribeDcdnIpaDomainDetailRequest.h"
@@ -128,14 +144,22 @@
 #include "model/DescribeDcdnRefreshTasksResult.h"
 #include "model/DescribeDcdnServiceRequest.h"
 #include "model/DescribeDcdnServiceResult.h"
+#include "model/DescribeDcdnStagingIpRequest.h"
+#include "model/DescribeDcdnStagingIpResult.h"
+#include "model/DescribeDcdnTagResourcesRequest.h"
+#include "model/DescribeDcdnTagResourcesResult.h"
 #include "model/DescribeDcdnTopDomainsByFlowRequest.h"
 #include "model/DescribeDcdnTopDomainsByFlowResult.h"
+#include "model/DescribeDcdnUserBillTypeRequest.h"
+#include "model/DescribeDcdnUserBillTypeResult.h"
 #include "model/DescribeDcdnUserDomainsRequest.h"
 #include "model/DescribeDcdnUserDomainsResult.h"
 #include "model/DescribeDcdnUserQuotaRequest.h"
 #include "model/DescribeDcdnUserQuotaResult.h"
 #include "model/DescribeDcdnUserResourcePackageRequest.h"
 #include "model/DescribeDcdnUserResourcePackageResult.h"
+#include "model/DescribeDcdnUserTagsRequest.h"
+#include "model/DescribeDcdnUserTagsResult.h"
 #include "model/DescribeUserDcdnIpaStatusRequest.h"
 #include "model/DescribeUserDcdnIpaStatusResult.h"
 #include "model/DescribeUserDcdnStatusRequest.h"
@@ -144,10 +168,18 @@
 #include "model/ModifyDCdnDomainSchdmByPropertyResult.h"
 #include "model/PreloadDcdnObjectCachesRequest.h"
 #include "model/PreloadDcdnObjectCachesResult.h"
+#include "model/PublishDcdnStagingConfigToProductionRequest.h"
+#include "model/PublishDcdnStagingConfigToProductionResult.h"
 #include "model/RefreshDcdnObjectCachesRequest.h"
 #include "model/RefreshDcdnObjectCachesResult.h"
+#include "model/RollbackDcdnStagingConfigRequest.h"
+#include "model/RollbackDcdnStagingConfigResult.h"
+#include "model/SetDcdnConfigOfVersionRequest.h"
+#include "model/SetDcdnConfigOfVersionResult.h"
 #include "model/SetDcdnDomainCertificateRequest.h"
 #include "model/SetDcdnDomainCertificateResult.h"
+#include "model/SetDcdnDomainStagingConfigRequest.h"
+#include "model/SetDcdnDomainStagingConfigResult.h"
 #include "model/StartDcdnDomainRequest.h"
 #include "model/StartDcdnDomainResult.h"
 #include "model/StartDcdnIpaDomainRequest.h"
@@ -156,6 +188,10 @@
 #include "model/StopDcdnDomainResult.h"
 #include "model/StopDcdnIpaDomainRequest.h"
 #include "model/StopDcdnIpaDomainResult.h"
+#include "model/TagDcdnResourcesRequest.h"
+#include "model/TagDcdnResourcesResult.h"
+#include "model/UntagDcdnResourcesRequest.h"
+#include "model/UntagDcdnResourcesResult.h"
 #include "model/UpdateDcdnDomainRequest.h"
 #include "model/UpdateDcdnDomainResult.h"
 #include "model/UpdateDcdnIpaDomainRequest.h"
@@ -202,12 +238,24 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteDcdnSpecificConfigResult> DeleteDcdnSpecificConfigOutcome;
 			typedef std::future<DeleteDcdnSpecificConfigOutcome> DeleteDcdnSpecificConfigOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DeleteDcdnSpecificConfigRequest&, const DeleteDcdnSpecificConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDcdnSpecificConfigAsyncHandler;
+			typedef Outcome<Error, Model::DeleteDcdnSpecificStagingConfigResult> DeleteDcdnSpecificStagingConfigOutcome;
+			typedef std::future<DeleteDcdnSpecificStagingConfigOutcome> DeleteDcdnSpecificStagingConfigOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DeleteDcdnSpecificStagingConfigRequest&, const DeleteDcdnSpecificStagingConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDcdnSpecificStagingConfigAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnBgpBpsDataResult> DescribeDcdnBgpBpsDataOutcome;
+			typedef std::future<DescribeDcdnBgpBpsDataOutcome> DescribeDcdnBgpBpsDataOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnBgpBpsDataRequest&, const DescribeDcdnBgpBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnBgpBpsDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnBgpTrafficDataResult> DescribeDcdnBgpTrafficDataOutcome;
+			typedef std::future<DescribeDcdnBgpTrafficDataOutcome> DescribeDcdnBgpTrafficDataOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnBgpTrafficDataRequest&, const DescribeDcdnBgpTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnBgpTrafficDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnCertificateDetailResult> DescribeDcdnCertificateDetailOutcome;
 			typedef std::future<DescribeDcdnCertificateDetailOutcome> DescribeDcdnCertificateDetailOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnCertificateDetailRequest&, const DescribeDcdnCertificateDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnCertificateDetailAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnCertificateListResult> DescribeDcdnCertificateListOutcome;
 			typedef std::future<DescribeDcdnCertificateListOutcome> DescribeDcdnCertificateListOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnCertificateListRequest&, const DescribeDcdnCertificateListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnCertificateListAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnConfigOfVersionResult> DescribeDcdnConfigOfVersionOutcome;
+			typedef std::future<DescribeDcdnConfigOfVersionOutcome> DescribeDcdnConfigOfVersionOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnConfigOfVersionRequest&, const DescribeDcdnConfigOfVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnConfigOfVersionAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnDomainBpsDataResult> DescribeDcdnDomainBpsDataOutcome;
 			typedef std::future<DescribeDcdnDomainBpsDataOutcome> DescribeDcdnDomainBpsDataOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainBpsDataRequest&, const DescribeDcdnDomainBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainBpsDataAsyncHandler;
@@ -244,6 +292,9 @@ 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::DescribeDcdnDomainMultiUsageDataResult> DescribeDcdnDomainMultiUsageDataOutcome;
+			typedef std::future<DescribeDcdnDomainMultiUsageDataOutcome> DescribeDcdnDomainMultiUsageDataOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainMultiUsageDataRequest&, const DescribeDcdnDomainMultiUsageDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainMultiUsageDataAsyncHandler;
 			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;
@@ -277,12 +328,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDcdnDomainRealTimeSrcBpsDataResult> DescribeDcdnDomainRealTimeSrcBpsDataOutcome;
 			typedef std::future<DescribeDcdnDomainRealTimeSrcBpsDataOutcome> DescribeDcdnDomainRealTimeSrcBpsDataOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainRealTimeSrcBpsDataRequest&, const DescribeDcdnDomainRealTimeSrcBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainRealTimeSrcBpsDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnDomainRealTimeSrcHttpCodeDataResult> DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcome;
+			typedef std::future<DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcome> DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest&, const DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainRealTimeSrcHttpCodeDataAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnDomainRealTimeSrcTrafficDataResult> DescribeDcdnDomainRealTimeSrcTrafficDataOutcome;
 			typedef std::future<DescribeDcdnDomainRealTimeSrcTrafficDataOutcome> DescribeDcdnDomainRealTimeSrcTrafficDataOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainRealTimeSrcTrafficDataRequest&, const DescribeDcdnDomainRealTimeSrcTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainRealTimeSrcTrafficDataAsyncHandler;
 			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::DescribeDcdnDomainStagingConfigResult> DescribeDcdnDomainStagingConfigOutcome;
+			typedef std::future<DescribeDcdnDomainStagingConfigOutcome> DescribeDcdnDomainStagingConfigOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainStagingConfigRequest&, const DescribeDcdnDomainStagingConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainStagingConfigAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnDomainTopReferVisitResult> DescribeDcdnDomainTopReferVisitOutcome;
 			typedef std::future<DescribeDcdnDomainTopReferVisitOutcome> DescribeDcdnDomainTopReferVisitOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnDomainTopReferVisitRequest&, const DescribeDcdnDomainTopReferVisitOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnDomainTopReferVisitAsyncHandler;
@@ -307,6 +364,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDcdnHttpsDomainListResult> DescribeDcdnHttpsDomainListOutcome;
 			typedef std::future<DescribeDcdnHttpsDomainListOutcome> DescribeDcdnHttpsDomainListOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnHttpsDomainListRequest&, const DescribeDcdnHttpsDomainListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnHttpsDomainListAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnIpInfoResult> DescribeDcdnIpInfoOutcome;
+			typedef std::future<DescribeDcdnIpInfoOutcome> DescribeDcdnIpInfoOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnIpInfoRequest&, const DescribeDcdnIpInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnIpInfoAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnIpaDomainConfigsResult> DescribeDcdnIpaDomainConfigsOutcome;
 			typedef std::future<DescribeDcdnIpaDomainConfigsOutcome> DescribeDcdnIpaDomainConfigsOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnIpaDomainConfigsRequest&, const DescribeDcdnIpaDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnIpaDomainConfigsAsyncHandler;
@@ -328,9 +388,18 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDcdnServiceResult> DescribeDcdnServiceOutcome;
 			typedef std::future<DescribeDcdnServiceOutcome> DescribeDcdnServiceOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnServiceRequest&, const DescribeDcdnServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnServiceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnStagingIpResult> DescribeDcdnStagingIpOutcome;
+			typedef std::future<DescribeDcdnStagingIpOutcome> DescribeDcdnStagingIpOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnStagingIpRequest&, const DescribeDcdnStagingIpOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnStagingIpAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnTagResourcesResult> DescribeDcdnTagResourcesOutcome;
+			typedef std::future<DescribeDcdnTagResourcesOutcome> DescribeDcdnTagResourcesOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnTagResourcesRequest&, const DescribeDcdnTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnTagResourcesAsyncHandler;
 			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::DescribeDcdnUserBillTypeResult> DescribeDcdnUserBillTypeOutcome;
+			typedef std::future<DescribeDcdnUserBillTypeOutcome> DescribeDcdnUserBillTypeOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnUserBillTypeRequest&, const DescribeDcdnUserBillTypeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnUserBillTypeAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDcdnUserDomainsResult> DescribeDcdnUserDomainsOutcome;
 			typedef std::future<DescribeDcdnUserDomainsOutcome> DescribeDcdnUserDomainsOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnUserDomainsRequest&, const DescribeDcdnUserDomainsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnUserDomainsAsyncHandler;
@@ -340,6 +409,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDcdnUserResourcePackageResult> DescribeDcdnUserResourcePackageOutcome;
 			typedef std::future<DescribeDcdnUserResourcePackageOutcome> DescribeDcdnUserResourcePackageOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnUserResourcePackageRequest&, const DescribeDcdnUserResourcePackageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnUserResourcePackageAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDcdnUserTagsResult> DescribeDcdnUserTagsOutcome;
+			typedef std::future<DescribeDcdnUserTagsOutcome> DescribeDcdnUserTagsOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::DescribeDcdnUserTagsRequest&, const DescribeDcdnUserTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDcdnUserTagsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeUserDcdnIpaStatusResult> DescribeUserDcdnIpaStatusOutcome;
 			typedef std::future<DescribeUserDcdnIpaStatusOutcome> DescribeUserDcdnIpaStatusOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::DescribeUserDcdnIpaStatusRequest&, const DescribeUserDcdnIpaStatusOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserDcdnIpaStatusAsyncHandler;
@@ -352,12 +424,24 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::PreloadDcdnObjectCachesResult> PreloadDcdnObjectCachesOutcome;
 			typedef std::future<PreloadDcdnObjectCachesOutcome> PreloadDcdnObjectCachesOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::PreloadDcdnObjectCachesRequest&, const PreloadDcdnObjectCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PreloadDcdnObjectCachesAsyncHandler;
+			typedef Outcome<Error, Model::PublishDcdnStagingConfigToProductionResult> PublishDcdnStagingConfigToProductionOutcome;
+			typedef std::future<PublishDcdnStagingConfigToProductionOutcome> PublishDcdnStagingConfigToProductionOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::PublishDcdnStagingConfigToProductionRequest&, const PublishDcdnStagingConfigToProductionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PublishDcdnStagingConfigToProductionAsyncHandler;
 			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::RollbackDcdnStagingConfigResult> RollbackDcdnStagingConfigOutcome;
+			typedef std::future<RollbackDcdnStagingConfigOutcome> RollbackDcdnStagingConfigOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::RollbackDcdnStagingConfigRequest&, const RollbackDcdnStagingConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RollbackDcdnStagingConfigAsyncHandler;
+			typedef Outcome<Error, Model::SetDcdnConfigOfVersionResult> SetDcdnConfigOfVersionOutcome;
+			typedef std::future<SetDcdnConfigOfVersionOutcome> SetDcdnConfigOfVersionOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::SetDcdnConfigOfVersionRequest&, const SetDcdnConfigOfVersionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDcdnConfigOfVersionAsyncHandler;
 			typedef Outcome<Error, Model::SetDcdnDomainCertificateResult> SetDcdnDomainCertificateOutcome;
 			typedef std::future<SetDcdnDomainCertificateOutcome> SetDcdnDomainCertificateOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::SetDcdnDomainCertificateRequest&, const SetDcdnDomainCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDcdnDomainCertificateAsyncHandler;
+			typedef Outcome<Error, Model::SetDcdnDomainStagingConfigResult> SetDcdnDomainStagingConfigOutcome;
+			typedef std::future<SetDcdnDomainStagingConfigOutcome> SetDcdnDomainStagingConfigOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::SetDcdnDomainStagingConfigRequest&, const SetDcdnDomainStagingConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetDcdnDomainStagingConfigAsyncHandler;
 			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;
@@ -370,6 +454,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::StopDcdnIpaDomainResult> StopDcdnIpaDomainOutcome;
 			typedef std::future<StopDcdnIpaDomainOutcome> StopDcdnIpaDomainOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::StopDcdnIpaDomainRequest&, const StopDcdnIpaDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopDcdnIpaDomainAsyncHandler;
+			typedef Outcome<Error, Model::TagDcdnResourcesResult> TagDcdnResourcesOutcome;
+			typedef std::future<TagDcdnResourcesOutcome> TagDcdnResourcesOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::TagDcdnResourcesRequest&, const TagDcdnResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagDcdnResourcesAsyncHandler;
+			typedef Outcome<Error, Model::UntagDcdnResourcesResult> UntagDcdnResourcesOutcome;
+			typedef std::future<UntagDcdnResourcesOutcome> UntagDcdnResourcesOutcomeCallable;
+			typedef std::function<void(const DcdnClient*, const Model::UntagDcdnResourcesRequest&, const UntagDcdnResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagDcdnResourcesAsyncHandler;
 			typedef Outcome<Error, Model::UpdateDcdnDomainResult> UpdateDcdnDomainOutcome;
 			typedef std::future<UpdateDcdnDomainOutcome> UpdateDcdnDomainOutcomeCallable;
 			typedef std::function<void(const DcdnClient*, const Model::UpdateDcdnDomainRequest&, const UpdateDcdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDcdnDomainAsyncHandler;
@@ -414,12 +504,24 @@ namespace AlibabaCloud
 			DeleteDcdnSpecificConfigOutcome deleteDcdnSpecificConfig(const Model::DeleteDcdnSpecificConfigRequest &request)const;
 			void deleteDcdnSpecificConfigAsync(const Model::DeleteDcdnSpecificConfigRequest& request, const DeleteDcdnSpecificConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteDcdnSpecificConfigOutcomeCallable deleteDcdnSpecificConfigCallable(const Model::DeleteDcdnSpecificConfigRequest& request) const;
+			DeleteDcdnSpecificStagingConfigOutcome deleteDcdnSpecificStagingConfig(const Model::DeleteDcdnSpecificStagingConfigRequest &request)const;
+			void deleteDcdnSpecificStagingConfigAsync(const Model::DeleteDcdnSpecificStagingConfigRequest& request, const DeleteDcdnSpecificStagingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteDcdnSpecificStagingConfigOutcomeCallable deleteDcdnSpecificStagingConfigCallable(const Model::DeleteDcdnSpecificStagingConfigRequest& request) const;
+			DescribeDcdnBgpBpsDataOutcome describeDcdnBgpBpsData(const Model::DescribeDcdnBgpBpsDataRequest &request)const;
+			void describeDcdnBgpBpsDataAsync(const Model::DescribeDcdnBgpBpsDataRequest& request, const DescribeDcdnBgpBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnBgpBpsDataOutcomeCallable describeDcdnBgpBpsDataCallable(const Model::DescribeDcdnBgpBpsDataRequest& request) const;
+			DescribeDcdnBgpTrafficDataOutcome describeDcdnBgpTrafficData(const Model::DescribeDcdnBgpTrafficDataRequest &request)const;
+			void describeDcdnBgpTrafficDataAsync(const Model::DescribeDcdnBgpTrafficDataRequest& request, const DescribeDcdnBgpTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnBgpTrafficDataOutcomeCallable describeDcdnBgpTrafficDataCallable(const Model::DescribeDcdnBgpTrafficDataRequest& request) const;
 			DescribeDcdnCertificateDetailOutcome describeDcdnCertificateDetail(const Model::DescribeDcdnCertificateDetailRequest &request)const;
 			void describeDcdnCertificateDetailAsync(const Model::DescribeDcdnCertificateDetailRequest& request, const DescribeDcdnCertificateDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnCertificateDetailOutcomeCallable describeDcdnCertificateDetailCallable(const Model::DescribeDcdnCertificateDetailRequest& request) const;
 			DescribeDcdnCertificateListOutcome describeDcdnCertificateList(const Model::DescribeDcdnCertificateListRequest &request)const;
 			void describeDcdnCertificateListAsync(const Model::DescribeDcdnCertificateListRequest& request, const DescribeDcdnCertificateListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnCertificateListOutcomeCallable describeDcdnCertificateListCallable(const Model::DescribeDcdnCertificateListRequest& request) const;
+			DescribeDcdnConfigOfVersionOutcome describeDcdnConfigOfVersion(const Model::DescribeDcdnConfigOfVersionRequest &request)const;
+			void describeDcdnConfigOfVersionAsync(const Model::DescribeDcdnConfigOfVersionRequest& request, const DescribeDcdnConfigOfVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnConfigOfVersionOutcomeCallable describeDcdnConfigOfVersionCallable(const Model::DescribeDcdnConfigOfVersionRequest& request) const;
 			DescribeDcdnDomainBpsDataOutcome describeDcdnDomainBpsData(const Model::DescribeDcdnDomainBpsDataRequest &request)const;
 			void describeDcdnDomainBpsDataAsync(const Model::DescribeDcdnDomainBpsDataRequest& request, const DescribeDcdnDomainBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnDomainBpsDataOutcomeCallable describeDcdnDomainBpsDataCallable(const Model::DescribeDcdnDomainBpsDataRequest& request) const;
@@ -456,6 +558,9 @@ 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;
+			DescribeDcdnDomainMultiUsageDataOutcome describeDcdnDomainMultiUsageData(const Model::DescribeDcdnDomainMultiUsageDataRequest &request)const;
+			void describeDcdnDomainMultiUsageDataAsync(const Model::DescribeDcdnDomainMultiUsageDataRequest& request, const DescribeDcdnDomainMultiUsageDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnDomainMultiUsageDataOutcomeCallable describeDcdnDomainMultiUsageDataCallable(const Model::DescribeDcdnDomainMultiUsageDataRequest& 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;
@@ -489,12 +594,18 @@ namespace AlibabaCloud
 			DescribeDcdnDomainRealTimeSrcBpsDataOutcome describeDcdnDomainRealTimeSrcBpsData(const Model::DescribeDcdnDomainRealTimeSrcBpsDataRequest &request)const;
 			void describeDcdnDomainRealTimeSrcBpsDataAsync(const Model::DescribeDcdnDomainRealTimeSrcBpsDataRequest& request, const DescribeDcdnDomainRealTimeSrcBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnDomainRealTimeSrcBpsDataOutcomeCallable describeDcdnDomainRealTimeSrcBpsDataCallable(const Model::DescribeDcdnDomainRealTimeSrcBpsDataRequest& request) const;
+			DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcome describeDcdnDomainRealTimeSrcHttpCodeData(const Model::DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest &request)const;
+			void describeDcdnDomainRealTimeSrcHttpCodeDataAsync(const Model::DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest& request, const DescribeDcdnDomainRealTimeSrcHttpCodeDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcomeCallable describeDcdnDomainRealTimeSrcHttpCodeDataCallable(const Model::DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest& request) const;
 			DescribeDcdnDomainRealTimeSrcTrafficDataOutcome describeDcdnDomainRealTimeSrcTrafficData(const Model::DescribeDcdnDomainRealTimeSrcTrafficDataRequest &request)const;
 			void describeDcdnDomainRealTimeSrcTrafficDataAsync(const Model::DescribeDcdnDomainRealTimeSrcTrafficDataRequest& request, const DescribeDcdnDomainRealTimeSrcTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnDomainRealTimeSrcTrafficDataOutcomeCallable describeDcdnDomainRealTimeSrcTrafficDataCallable(const Model::DescribeDcdnDomainRealTimeSrcTrafficDataRequest& 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;
+			DescribeDcdnDomainStagingConfigOutcome describeDcdnDomainStagingConfig(const Model::DescribeDcdnDomainStagingConfigRequest &request)const;
+			void describeDcdnDomainStagingConfigAsync(const Model::DescribeDcdnDomainStagingConfigRequest& request, const DescribeDcdnDomainStagingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnDomainStagingConfigOutcomeCallable describeDcdnDomainStagingConfigCallable(const Model::DescribeDcdnDomainStagingConfigRequest& request) const;
 			DescribeDcdnDomainTopReferVisitOutcome describeDcdnDomainTopReferVisit(const Model::DescribeDcdnDomainTopReferVisitRequest &request)const;
 			void describeDcdnDomainTopReferVisitAsync(const Model::DescribeDcdnDomainTopReferVisitRequest& request, const DescribeDcdnDomainTopReferVisitAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnDomainTopReferVisitOutcomeCallable describeDcdnDomainTopReferVisitCallable(const Model::DescribeDcdnDomainTopReferVisitRequest& request) const;
@@ -519,6 +630,9 @@ namespace AlibabaCloud
 			DescribeDcdnHttpsDomainListOutcome describeDcdnHttpsDomainList(const Model::DescribeDcdnHttpsDomainListRequest &request)const;
 			void describeDcdnHttpsDomainListAsync(const Model::DescribeDcdnHttpsDomainListRequest& request, const DescribeDcdnHttpsDomainListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnHttpsDomainListOutcomeCallable describeDcdnHttpsDomainListCallable(const Model::DescribeDcdnHttpsDomainListRequest& request) const;
+			DescribeDcdnIpInfoOutcome describeDcdnIpInfo(const Model::DescribeDcdnIpInfoRequest &request)const;
+			void describeDcdnIpInfoAsync(const Model::DescribeDcdnIpInfoRequest& request, const DescribeDcdnIpInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnIpInfoOutcomeCallable describeDcdnIpInfoCallable(const Model::DescribeDcdnIpInfoRequest& request) const;
 			DescribeDcdnIpaDomainConfigsOutcome describeDcdnIpaDomainConfigs(const Model::DescribeDcdnIpaDomainConfigsRequest &request)const;
 			void describeDcdnIpaDomainConfigsAsync(const Model::DescribeDcdnIpaDomainConfigsRequest& request, const DescribeDcdnIpaDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnIpaDomainConfigsOutcomeCallable describeDcdnIpaDomainConfigsCallable(const Model::DescribeDcdnIpaDomainConfigsRequest& request) const;
@@ -540,9 +654,18 @@ namespace AlibabaCloud
 			DescribeDcdnServiceOutcome describeDcdnService(const Model::DescribeDcdnServiceRequest &request)const;
 			void describeDcdnServiceAsync(const Model::DescribeDcdnServiceRequest& request, const DescribeDcdnServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnServiceOutcomeCallable describeDcdnServiceCallable(const Model::DescribeDcdnServiceRequest& request) const;
+			DescribeDcdnStagingIpOutcome describeDcdnStagingIp(const Model::DescribeDcdnStagingIpRequest &request)const;
+			void describeDcdnStagingIpAsync(const Model::DescribeDcdnStagingIpRequest& request, const DescribeDcdnStagingIpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnStagingIpOutcomeCallable describeDcdnStagingIpCallable(const Model::DescribeDcdnStagingIpRequest& request) const;
+			DescribeDcdnTagResourcesOutcome describeDcdnTagResources(const Model::DescribeDcdnTagResourcesRequest &request)const;
+			void describeDcdnTagResourcesAsync(const Model::DescribeDcdnTagResourcesRequest& request, const DescribeDcdnTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnTagResourcesOutcomeCallable describeDcdnTagResourcesCallable(const Model::DescribeDcdnTagResourcesRequest& 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;
+			DescribeDcdnUserBillTypeOutcome describeDcdnUserBillType(const Model::DescribeDcdnUserBillTypeRequest &request)const;
+			void describeDcdnUserBillTypeAsync(const Model::DescribeDcdnUserBillTypeRequest& request, const DescribeDcdnUserBillTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnUserBillTypeOutcomeCallable describeDcdnUserBillTypeCallable(const Model::DescribeDcdnUserBillTypeRequest& request) const;
 			DescribeDcdnUserDomainsOutcome describeDcdnUserDomains(const Model::DescribeDcdnUserDomainsRequest &request)const;
 			void describeDcdnUserDomainsAsync(const Model::DescribeDcdnUserDomainsRequest& request, const DescribeDcdnUserDomainsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnUserDomainsOutcomeCallable describeDcdnUserDomainsCallable(const Model::DescribeDcdnUserDomainsRequest& request) const;
@@ -552,6 +675,9 @@ namespace AlibabaCloud
 			DescribeDcdnUserResourcePackageOutcome describeDcdnUserResourcePackage(const Model::DescribeDcdnUserResourcePackageRequest &request)const;
 			void describeDcdnUserResourcePackageAsync(const Model::DescribeDcdnUserResourcePackageRequest& request, const DescribeDcdnUserResourcePackageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDcdnUserResourcePackageOutcomeCallable describeDcdnUserResourcePackageCallable(const Model::DescribeDcdnUserResourcePackageRequest& request) const;
+			DescribeDcdnUserTagsOutcome describeDcdnUserTags(const Model::DescribeDcdnUserTagsRequest &request)const;
+			void describeDcdnUserTagsAsync(const Model::DescribeDcdnUserTagsRequest& request, const DescribeDcdnUserTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDcdnUserTagsOutcomeCallable describeDcdnUserTagsCallable(const Model::DescribeDcdnUserTagsRequest& request) const;
 			DescribeUserDcdnIpaStatusOutcome describeUserDcdnIpaStatus(const Model::DescribeUserDcdnIpaStatusRequest &request)const;
 			void describeUserDcdnIpaStatusAsync(const Model::DescribeUserDcdnIpaStatusRequest& request, const DescribeUserDcdnIpaStatusAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeUserDcdnIpaStatusOutcomeCallable describeUserDcdnIpaStatusCallable(const Model::DescribeUserDcdnIpaStatusRequest& request) const;
@@ -564,12 +690,24 @@ namespace AlibabaCloud
 			PreloadDcdnObjectCachesOutcome preloadDcdnObjectCaches(const Model::PreloadDcdnObjectCachesRequest &request)const;
 			void preloadDcdnObjectCachesAsync(const Model::PreloadDcdnObjectCachesRequest& request, const PreloadDcdnObjectCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			PreloadDcdnObjectCachesOutcomeCallable preloadDcdnObjectCachesCallable(const Model::PreloadDcdnObjectCachesRequest& request) const;
+			PublishDcdnStagingConfigToProductionOutcome publishDcdnStagingConfigToProduction(const Model::PublishDcdnStagingConfigToProductionRequest &request)const;
+			void publishDcdnStagingConfigToProductionAsync(const Model::PublishDcdnStagingConfigToProductionRequest& request, const PublishDcdnStagingConfigToProductionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PublishDcdnStagingConfigToProductionOutcomeCallable publishDcdnStagingConfigToProductionCallable(const Model::PublishDcdnStagingConfigToProductionRequest& request) const;
 			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;
+			RollbackDcdnStagingConfigOutcome rollbackDcdnStagingConfig(const Model::RollbackDcdnStagingConfigRequest &request)const;
+			void rollbackDcdnStagingConfigAsync(const Model::RollbackDcdnStagingConfigRequest& request, const RollbackDcdnStagingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RollbackDcdnStagingConfigOutcomeCallable rollbackDcdnStagingConfigCallable(const Model::RollbackDcdnStagingConfigRequest& request) const;
+			SetDcdnConfigOfVersionOutcome setDcdnConfigOfVersion(const Model::SetDcdnConfigOfVersionRequest &request)const;
+			void setDcdnConfigOfVersionAsync(const Model::SetDcdnConfigOfVersionRequest& request, const SetDcdnConfigOfVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetDcdnConfigOfVersionOutcomeCallable setDcdnConfigOfVersionCallable(const Model::SetDcdnConfigOfVersionRequest& request) const;
 			SetDcdnDomainCertificateOutcome setDcdnDomainCertificate(const Model::SetDcdnDomainCertificateRequest &request)const;
 			void setDcdnDomainCertificateAsync(const Model::SetDcdnDomainCertificateRequest& request, const SetDcdnDomainCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			SetDcdnDomainCertificateOutcomeCallable setDcdnDomainCertificateCallable(const Model::SetDcdnDomainCertificateRequest& request) const;
+			SetDcdnDomainStagingConfigOutcome setDcdnDomainStagingConfig(const Model::SetDcdnDomainStagingConfigRequest &request)const;
+			void setDcdnDomainStagingConfigAsync(const Model::SetDcdnDomainStagingConfigRequest& request, const SetDcdnDomainStagingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetDcdnDomainStagingConfigOutcomeCallable setDcdnDomainStagingConfigCallable(const Model::SetDcdnDomainStagingConfigRequest& 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;
@@ -582,6 +720,12 @@ namespace AlibabaCloud
 			StopDcdnIpaDomainOutcome stopDcdnIpaDomain(const Model::StopDcdnIpaDomainRequest &request)const;
 			void stopDcdnIpaDomainAsync(const Model::StopDcdnIpaDomainRequest& request, const StopDcdnIpaDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StopDcdnIpaDomainOutcomeCallable stopDcdnIpaDomainCallable(const Model::StopDcdnIpaDomainRequest& request) const;
+			TagDcdnResourcesOutcome tagDcdnResources(const Model::TagDcdnResourcesRequest &request)const;
+			void tagDcdnResourcesAsync(const Model::TagDcdnResourcesRequest& request, const TagDcdnResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TagDcdnResourcesOutcomeCallable tagDcdnResourcesCallable(const Model::TagDcdnResourcesRequest& request) const;
+			UntagDcdnResourcesOutcome untagDcdnResources(const Model::UntagDcdnResourcesRequest &request)const;
+			void untagDcdnResourcesAsync(const Model::UntagDcdnResourcesRequest& request, const UntagDcdnResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UntagDcdnResourcesOutcomeCallable untagDcdnResourcesCallable(const Model::UntagDcdnResourcesRequest& request) const;
 			UpdateDcdnDomainOutcome updateDcdnDomain(const Model::UpdateDcdnDomainRequest &request)const;
 			void updateDcdnDomainAsync(const Model::UpdateDcdnDomainRequest& request, const UpdateDcdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateDcdnDomainOutcomeCallable updateDcdnDomainCallable(const Model::UpdateDcdnDomainRequest& request) const;

dcdn/include/alibabacloud/dcdn/model/DeleteDcdnSpecificStagingConfigRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DELETEDCDNSPECIFICSTAGINGCONFIGREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DELETEDCDNSPECIFICSTAGINGCONFIGREQUEST_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 DeleteDcdnSpecificStagingConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				DeleteDcdnSpecificStagingConfigRequest();
+				~DeleteDcdnSpecificStagingConfigRequest();
+
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getConfigId()const;
+				void setConfigId(const std::string& configId);
+
+            private:
+				std::string securityToken_;
+				std::string domainName_;
+				long ownerId_;
+				std::string configId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DELETEDCDNSPECIFICSTAGINGCONFIGREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DeleteDcdnSpecificStagingConfigResult.h

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

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnBgpBpsDataRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPBPSDATAREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPBPSDATAREQUEST_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 DescribeDcdnBgpBpsDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnBgpBpsDataRequest();
+				~DescribeDcdnBgpBpsDataRequest();
+
+				std::string getIsp()const;
+				void setIsp(const std::string& isp);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+
+            private:
+				std::string isp_;
+				std::string startTime_;
+				std::string endTime_;
+				long ownerId_;
+				std::string interval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPBPSDATAREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnBgpBpsDataResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPBPSDATARESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPBPSDATARESULT_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 DescribeDcdnBgpBpsDataResult : public ServiceResult
+			{
+			public:
+				struct BgpData
+				{
+					float in;
+					std::string timeStamp;
+					float out;
+				};
+
+
+				DescribeDcdnBgpBpsDataResult();
+				explicit DescribeDcdnBgpBpsDataResult(const std::string &payload);
+				~DescribeDcdnBgpBpsDataResult();
+				std::string getEndTime()const;
+				std::string getStartTime()const;
+				std::vector<BgpData> getBgpDataInterval()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				std::string startTime_;
+				std::vector<BgpData> bgpDataInterval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPBPSDATARESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnBgpTrafficDataRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPTRAFFICDATAREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPTRAFFICDATAREQUEST_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 DescribeDcdnBgpTrafficDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnBgpTrafficDataRequest();
+				~DescribeDcdnBgpTrafficDataRequest();
+
+				std::string getIsp()const;
+				void setIsp(const std::string& isp);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+
+            private:
+				std::string isp_;
+				std::string startTime_;
+				std::string endTime_;
+				long ownerId_;
+				std::string interval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPTRAFFICDATAREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnBgpTrafficDataResult.h

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPTRAFFICDATARESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPTRAFFICDATARESULT_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 DescribeDcdnBgpTrafficDataResult : public ServiceResult
+			{
+			public:
+				struct BgpData
+				{
+					long in;
+					std::string timeStamp;
+					long out;
+				};
+
+
+				DescribeDcdnBgpTrafficDataResult();
+				explicit DescribeDcdnBgpTrafficDataResult(const std::string &payload);
+				~DescribeDcdnBgpTrafficDataResult();
+				std::string getEndTime()const;
+				std::string getStartTime()const;
+				std::vector<BgpData> getBgpDataInterval()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				std::string startTime_;
+				std::vector<BgpData> bgpDataInterval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNBGPTRAFFICDATARESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnConfigOfVersionRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNCONFIGOFVERSIONREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNCONFIGOFVERSIONREQUEST_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 DescribeDcdnConfigOfVersionRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnConfigOfVersionRequest();
+				~DescribeDcdnConfigOfVersionRequest();
+
+				std::string getVersionId()const;
+				void setVersionId(const std::string& versionId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getFunctionName()const;
+				void setFunctionName(const std::string& functionName);
+				long getGroupId()const;
+				void setGroupId(long groupId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getFunctionId()const;
+				void setFunctionId(int functionId);
+
+            private:
+				std::string versionId_;
+				std::string securityToken_;
+				std::string functionName_;
+				long groupId_;
+				long ownerId_;
+				int functionId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNCONFIGOFVERSIONREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnConfigOfVersionResult.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNCONFIGOFVERSIONRESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNCONFIGOFVERSIONRESULT_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 DescribeDcdnConfigOfVersionResult : public ServiceResult
+			{
+			public:
+				struct VersionConfig
+				{
+					struct FunctionArg
+					{
+						std::string argValue;
+						std::string argName;
+					};
+					std::string status;
+					std::string functionName;
+					std::vector<VersionConfig::FunctionArg> functionArgs;
+					std::string configId;
+				};
+
+
+				DescribeDcdnConfigOfVersionResult();
+				explicit DescribeDcdnConfigOfVersionResult(const std::string &payload);
+				~DescribeDcdnConfigOfVersionResult();
+				std::vector<VersionConfig> getVersionConfigs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<VersionConfig> versionConfigs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNCONFIGOFVERSIONRESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainMultiUsageDataRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINMULTIUSAGEDATAREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINMULTIUSAGEDATAREQUEST_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 DescribeDcdnDomainMultiUsageDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnDomainMultiUsageDataRequest();
+				~DescribeDcdnDomainMultiUsageDataRequest();
+
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string startTime_;
+				std::string domainName_;
+				std::string endTime_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINMULTIUSAGEDATAREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainMultiUsageDataResult.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINMULTIUSAGEDATARESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINMULTIUSAGEDATARESULT_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 DescribeDcdnDomainMultiUsageDataResult : public ServiceResult
+			{
+			public:
+				struct RequestDataModule
+				{
+					std::string type;
+					long request;
+					std::string domain;
+					std::string timeStamp;
+				};
+				struct TrafficDataModule
+				{
+					std::string type;
+					std::string area;
+					float bps;
+					std::string domain;
+					std::string timeStamp;
+				};
+
+
+				DescribeDcdnDomainMultiUsageDataResult();
+				explicit DescribeDcdnDomainMultiUsageDataResult(const std::string &payload);
+				~DescribeDcdnDomainMultiUsageDataResult();
+				std::string getEndTime()const;
+				std::string getStartTime()const;
+				std::vector<RequestDataModule> getRequestPerInterval()const;
+				std::vector<TrafficDataModule> getTrafficPerInterval()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				std::string startTime_;
+				std::vector<RequestDataModule> requestPerInterval_;
+				std::vector<TrafficDataModule> trafficPerInterval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINMULTIUSAGEDATARESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMESRCHTTPCODEDATAREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMESRCHTTPCODEDATAREQUEST_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 DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest();
+				~DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest();
+
+				std::string getLocationNameEn()const;
+				void setLocationNameEn(const std::string& locationNameEn);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getIspNameEn()const;
+				void setIspNameEn(const std::string& ispNameEn);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string locationNameEn_;
+				std::string startTime_;
+				std::string ispNameEn_;
+				std::string domainName_;
+				std::string endTime_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMESRCHTTPCODEDATAREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainRealTimeSrcHttpCodeDataResult.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMESRCHTTPCODEDATARESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMESRCHTTPCODEDATARESULT_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 DescribeDcdnDomainRealTimeSrcHttpCodeDataResult : public ServiceResult
+			{
+			public:
+				struct UsageData
+				{
+					struct RealTimeSrcCodeProportionData
+					{
+						std::string proportion;
+						std::string count;
+						std::string code;
+					};
+					std::vector<UsageData::RealTimeSrcCodeProportionData> value;
+					std::string timeStamp;
+				};
+
+
+				DescribeDcdnDomainRealTimeSrcHttpCodeDataResult();
+				explicit DescribeDcdnDomainRealTimeSrcHttpCodeDataResult(const std::string &payload);
+				~DescribeDcdnDomainRealTimeSrcHttpCodeDataResult();
+				std::string getEndTime()const;
+				std::string getDomainName()const;
+				std::string getStartTime()const;
+				std::string getDataInterval()const;
+				std::vector<UsageData> getRealTimeSrcHttpCodeData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				std::string domainName_;
+				std::string startTime_;
+				std::string dataInterval_;
+				std::vector<UsageData> realTimeSrcHttpCodeData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINREALTIMESRCHTTPCODEDATARESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainStagingConfigRequest.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_DESCRIBEDCDNDOMAINSTAGINGCONFIGREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINSTAGINGCONFIGREQUEST_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 DescribeDcdnDomainStagingConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnDomainStagingConfigRequest();
+				~DescribeDcdnDomainStagingConfigRequest();
+
+				std::string getFunctionNames()const;
+				void setFunctionNames(const std::string& functionNames);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string functionNames_;
+				std::string domainName_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINSTAGINGCONFIGREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnDomainStagingConfigResult.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINSTAGINGCONFIGRESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINSTAGINGCONFIGRESULT_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 DescribeDcdnDomainStagingConfigResult : public ServiceResult
+			{
+			public:
+				struct DomainConfig
+				{
+					struct FunctionArg
+					{
+						std::string argValue;
+						std::string argName;
+					};
+					std::string status;
+					std::string functionName;
+					std::vector<DomainConfig::FunctionArg> functionArgs;
+					std::string configId;
+				};
+
+
+				DescribeDcdnDomainStagingConfigResult();
+				explicit DescribeDcdnDomainStagingConfigResult(const std::string &payload);
+				~DescribeDcdnDomainStagingConfigResult();
+				std::vector<DomainConfig> getDomainConfigs()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DomainConfig> domainConfigs_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNDOMAINSTAGINGCONFIGRESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnIpInfoRequest.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_DESCRIBEDCDNIPINFOREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNIPINFOREQUEST_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 DescribeDcdnIpInfoRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnIpInfoRequest();
+				~DescribeDcdnIpInfoRequest();
+
+				std::string getIP()const;
+				void setIP(const std::string& iP);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+
+            private:
+				std::string iP_;
+				long ownerId_;
+				std::string securityToken_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNIPINFOREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnIpInfoResult.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNIPINFORESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNIPINFORESULT_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 DescribeDcdnIpInfoResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDcdnIpInfoResult();
+				explicit DescribeDcdnIpInfoResult(const std::string &payload);
+				~DescribeDcdnIpInfoResult();
+				std::string getISP()const;
+				std::string getRegion()const;
+				std::string getIspEname()const;
+				std::string getDcdnIp()const;
+				std::string getRegionEname()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string iSP_;
+				std::string region_;
+				std::string ispEname_;
+				std::string dcdnIp_;
+				std::string regionEname_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNIPINFORESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnStagingIpRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DESCRIBEDCDNSTAGINGIPREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNSTAGINGIPREQUEST_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 DescribeDcdnStagingIpRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnStagingIpRequest();
+				~DescribeDcdnStagingIpRequest();
+
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNSTAGINGIPREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnStagingIpResult.h

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

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnTagResourcesRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNTAGRESOURCESREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNTAGRESOURCESREQUEST_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 DescribeDcdnTagResourcesRequest : public RpcServiceRequest
+			{
+			public:
+				struct Tag
+				{
+					std::string key;
+					std::string value;
+				};
+
+			public:
+				DescribeDcdnTagResourcesRequest();
+				~DescribeDcdnTagResourcesRequest();
+
+				std::string getScope()const;
+				void setScope(const std::string& scope);
+				std::vector<Tag> getTag()const;
+				void setTag(const std::vector<Tag>& tag);
+				std::vector<std::string> getResourceId()const;
+				void setResourceId(const std::vector<std::string>& resourceId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+
+            private:
+				std::string scope_;
+				std::vector<Tag> tag_;
+				std::vector<std::string> resourceId_;
+				long ownerId_;
+				std::string resourceType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNTAGRESOURCESREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnTagResourcesResult.h

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

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserBillTypeRequest.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_DESCRIBEDCDNUSERBILLTYPEREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERBILLTYPEREQUEST_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 DescribeDcdnUserBillTypeRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnUserBillTypeRequest();
+				~DescribeDcdnUserBillTypeRequest();
+
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string startTime_;
+				std::string endTime_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERBILLTYPEREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserBillTypeResult.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERBILLTYPERESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERBILLTYPERESULT_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 DescribeDcdnUserBillTypeResult : public ServiceResult
+			{
+			public:
+				struct BillTypeDataItem
+				{
+					std::string billType;
+					std::string billingCycle;
+					std::string endTime;
+					std::string startTime;
+					std::string product;
+					std::string dimension;
+				};
+
+
+				DescribeDcdnUserBillTypeResult();
+				explicit DescribeDcdnUserBillTypeResult(const std::string &payload);
+				~DescribeDcdnUserBillTypeResult();
+				std::vector<BillTypeDataItem> getBillTypeData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<BillTypeDataItem> billTypeData_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERBILLTYPERESULT_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserTagsRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_DESCRIBEDCDNUSERTAGSREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERTAGSREQUEST_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 DescribeDcdnUserTagsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDcdnUserTagsRequest();
+				~DescribeDcdnUserTagsRequest();
+
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_DESCRIBEDCDNUSERTAGSREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/DescribeDcdnUserTagsResult.h

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

dcdn/include/alibabacloud/dcdn/model/PublishDcdnStagingConfigToProductionRequest.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_PUBLISHDCDNSTAGINGCONFIGTOPRODUCTIONREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_PUBLISHDCDNSTAGINGCONFIGTOPRODUCTIONREQUEST_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 PublishDcdnStagingConfigToProductionRequest : public RpcServiceRequest
+			{
+
+			public:
+				PublishDcdnStagingConfigToProductionRequest();
+				~PublishDcdnStagingConfigToProductionRequest();
+
+				std::string getFunctionName()const;
+				void setFunctionName(const std::string& functionName);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string functionName_;
+				std::string domainName_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_PUBLISHDCDNSTAGINGCONFIGTOPRODUCTIONREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/PublishDcdnStagingConfigToProductionResult.h

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

dcdn/include/alibabacloud/dcdn/model/RollbackDcdnStagingConfigRequest.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_ROLLBACKDCDNSTAGINGCONFIGREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_ROLLBACKDCDNSTAGINGCONFIGREQUEST_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 RollbackDcdnStagingConfigRequest : public RpcServiceRequest
+			{
+
+			public:
+				RollbackDcdnStagingConfigRequest();
+				~RollbackDcdnStagingConfigRequest();
+
+				std::string getFunctionName()const;
+				void setFunctionName(const std::string& functionName);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				std::string functionName_;
+				std::string domainName_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_ROLLBACKDCDNSTAGINGCONFIGREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/RollbackDcdnStagingConfigResult.h

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

dcdn/include/alibabacloud/dcdn/model/SetDcdnConfigOfVersionRequest.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_SETDCDNCONFIGOFVERSIONREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_SETDCDNCONFIGOFVERSIONREQUEST_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 SetDcdnConfigOfVersionRequest : public RpcServiceRequest
+			{
+
+			public:
+				SetDcdnConfigOfVersionRequest();
+				~SetDcdnConfigOfVersionRequest();
+
+				std::string getVersionId()const;
+				void setVersionId(const std::string& versionId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getFunctionName()const;
+				void setFunctionName(const std::string& functionName);
+				std::string getFunctionArgs()const;
+				void setFunctionArgs(const std::string& functionArgs);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				long getFunctionId()const;
+				void setFunctionId(long functionId);
+				std::string getConfigId()const;
+				void setConfigId(const std::string& configId);
+
+            private:
+				std::string versionId_;
+				std::string securityToken_;
+				std::string functionName_;
+				std::string functionArgs_;
+				std::string ownerAccount_;
+				long ownerId_;
+				long functionId_;
+				std::string configId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_SETDCDNCONFIGOFVERSIONREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/SetDcdnConfigOfVersionResult.h

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

dcdn/include/alibabacloud/dcdn/model/SetDcdnDomainStagingConfigRequest.h

@@ -14,44 +14,41 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_CDN_MODEL_SETWAFCONFIGREQUEST_H_
-#define ALIBABACLOUD_CDN_MODEL_SETWAFCONFIGREQUEST_H_
+#ifndef ALIBABACLOUD_DCDN_MODEL_SETDCDNDOMAINSTAGINGCONFIGREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_SETDCDNDOMAINSTAGINGCONFIGREQUEST_H_
 
 #include <string>
 #include <vector>
 #include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/cdn/CdnExport.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Cdn
+	namespace Dcdn
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_CDN_EXPORT SetWafConfigRequest : public RpcServiceRequest
+			class ALIBABACLOUD_DCDN_EXPORT SetDcdnDomainStagingConfigRequest : public RpcServiceRequest
 			{
 
 			public:
-				SetWafConfigRequest();
-				~SetWafConfigRequest();
+				SetDcdnDomainStagingConfigRequest();
+				~SetDcdnDomainStagingConfigRequest();
 
-				std::string getEnable()const;
-				void setEnable(const std::string& enable);
+				std::string getFunctions()const;
+				void setFunctions(const std::string& functions);
 				std::string getDomainName()const;
 				void setDomainName(const std::string& domainName);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
-				long getConfigId()const;
-				void setConfigId(long configId);
 
             private:
-				std::string enable_;
+				std::string functions_;
 				std::string domainName_;
 				long ownerId_;
-				long configId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_CDN_MODEL_SETWAFCONFIGREQUEST_H_
+#endif // !ALIBABACLOUD_DCDN_MODEL_SETDCDNDOMAINSTAGINGCONFIGREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/SetDcdnDomainStagingConfigResult.h

@@ -14,29 +14,29 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_SCDN_MODEL_SETDOMAINSERVERCERTIFICATERESULT_H_
-#define ALIBABACLOUD_SCDN_MODEL_SETDOMAINSERVERCERTIFICATERESULT_H_
+#ifndef ALIBABACLOUD_DCDN_MODEL_SETDCDNDOMAINSTAGINGCONFIGRESULT_H_
+#define ALIBABACLOUD_DCDN_MODEL_SETDCDNDOMAINSTAGINGCONFIGRESULT_H_
 
 #include <string>
 #include <vector>
 #include <utility>
 #include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/scdn/ScdnExport.h>
+#include <alibabacloud/dcdn/DcdnExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Scdn
+	namespace Dcdn
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_SCDN_EXPORT SetDomainServerCertificateResult : public ServiceResult
+			class ALIBABACLOUD_DCDN_EXPORT SetDcdnDomainStagingConfigResult : public ServiceResult
 			{
 			public:
 
 
-				SetDomainServerCertificateResult();
-				explicit SetDomainServerCertificateResult(const std::string &payload);
-				~SetDomainServerCertificateResult();
+				SetDcdnDomainStagingConfigResult();
+				explicit SetDcdnDomainStagingConfigResult(const std::string &payload);
+				~SetDcdnDomainStagingConfigResult();
 
 			protected:
 				void parse(const std::string &payload);
@@ -46,4 +46,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_SCDN_MODEL_SETDOMAINSERVERCERTIFICATERESULT_H_
+#endif // !ALIBABACLOUD_DCDN_MODEL_SETDCDNDOMAINSTAGINGCONFIGRESULT_H_

dcdn/include/alibabacloud/dcdn/model/TagDcdnResourcesRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_TAGDCDNRESOURCESREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_TAGDCDNRESOURCESREQUEST_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 TagDcdnResourcesRequest : public RpcServiceRequest
+			{
+			public:
+				struct Tag
+				{
+					std::string key;
+					std::string value;
+				};
+
+			public:
+				TagDcdnResourcesRequest();
+				~TagDcdnResourcesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::vector<Tag> getTag()const;
+				void setTag(const std::vector<Tag>& tag);
+				std::vector<std::string> getResourceId()const;
+				void setResourceId(const std::vector<std::string>& resourceId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+
+            private:
+				std::string regionId_;
+				std::vector<Tag> tag_;
+				std::vector<std::string> resourceId_;
+				long ownerId_;
+				std::string resourceType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_TAGDCDNRESOURCESREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/TagDcdnResourcesResult.h

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

dcdn/include/alibabacloud/dcdn/model/UntagDcdnResourcesRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_DCDN_MODEL_UNTAGDCDNRESOURCESREQUEST_H_
+#define ALIBABACLOUD_DCDN_MODEL_UNTAGDCDNRESOURCESREQUEST_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 UntagDcdnResourcesRequest : public RpcServiceRequest
+			{
+
+			public:
+				UntagDcdnResourcesRequest();
+				~UntagDcdnResourcesRequest();
+
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::vector<std::string> getResourceId()const;
+				void setResourceId(const std::vector<std::string>& resourceId);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getResourceType()const;
+				void setResourceType(const std::string& resourceType);
+				std::vector<std::string> getTagKey()const;
+				void setTagKey(const std::vector<std::string>& tagKey);
+
+            private:
+				std::string regionId_;
+				std::vector<std::string> resourceId_;
+				long ownerId_;
+				std::string resourceType_;
+				std::vector<std::string> tagKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_DCDN_MODEL_UNTAGDCDNRESOURCESREQUEST_H_

dcdn/include/alibabacloud/dcdn/model/UntagDcdnResourcesResult.h

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

dcdn/src/DcdnClient.cc

@@ -447,6 +447,114 @@ DcdnClient::DeleteDcdnSpecificConfigOutcomeCallable DcdnClient::deleteDcdnSpecif
 	return task->get_future();
 }
 
+DcdnClient::DeleteDcdnSpecificStagingConfigOutcome DcdnClient::deleteDcdnSpecificStagingConfig(const DeleteDcdnSpecificStagingConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteDcdnSpecificStagingConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteDcdnSpecificStagingConfigOutcome(DeleteDcdnSpecificStagingConfigResult(outcome.result()));
+	else
+		return DeleteDcdnSpecificStagingConfigOutcome(outcome.error());
+}
+
+void DcdnClient::deleteDcdnSpecificStagingConfigAsync(const DeleteDcdnSpecificStagingConfigRequest& request, const DeleteDcdnSpecificStagingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteDcdnSpecificStagingConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DeleteDcdnSpecificStagingConfigOutcomeCallable DcdnClient::deleteDcdnSpecificStagingConfigCallable(const DeleteDcdnSpecificStagingConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteDcdnSpecificStagingConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteDcdnSpecificStagingConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DcdnClient::DescribeDcdnBgpBpsDataOutcome DcdnClient::describeDcdnBgpBpsData(const DescribeDcdnBgpBpsDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnBgpBpsDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnBgpBpsDataOutcome(DescribeDcdnBgpBpsDataResult(outcome.result()));
+	else
+		return DescribeDcdnBgpBpsDataOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnBgpBpsDataAsync(const DescribeDcdnBgpBpsDataRequest& request, const DescribeDcdnBgpBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnBgpBpsData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnBgpBpsDataOutcomeCallable DcdnClient::describeDcdnBgpBpsDataCallable(const DescribeDcdnBgpBpsDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnBgpBpsDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnBgpBpsData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DcdnClient::DescribeDcdnBgpTrafficDataOutcome DcdnClient::describeDcdnBgpTrafficData(const DescribeDcdnBgpTrafficDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnBgpTrafficDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnBgpTrafficDataOutcome(DescribeDcdnBgpTrafficDataResult(outcome.result()));
+	else
+		return DescribeDcdnBgpTrafficDataOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnBgpTrafficDataAsync(const DescribeDcdnBgpTrafficDataRequest& request, const DescribeDcdnBgpTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnBgpTrafficData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnBgpTrafficDataOutcomeCallable DcdnClient::describeDcdnBgpTrafficDataCallable(const DescribeDcdnBgpTrafficDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnBgpTrafficDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnBgpTrafficData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnCertificateDetailOutcome DcdnClient::describeDcdnCertificateDetail(const DescribeDcdnCertificateDetailRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -519,6 +627,42 @@ DcdnClient::DescribeDcdnCertificateListOutcomeCallable DcdnClient::describeDcdnC
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnConfigOfVersionOutcome DcdnClient::describeDcdnConfigOfVersion(const DescribeDcdnConfigOfVersionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnConfigOfVersionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnConfigOfVersionOutcome(DescribeDcdnConfigOfVersionResult(outcome.result()));
+	else
+		return DescribeDcdnConfigOfVersionOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnConfigOfVersionAsync(const DescribeDcdnConfigOfVersionRequest& request, const DescribeDcdnConfigOfVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnConfigOfVersion(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnConfigOfVersionOutcomeCallable DcdnClient::describeDcdnConfigOfVersionCallable(const DescribeDcdnConfigOfVersionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnConfigOfVersionOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnConfigOfVersion(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnDomainBpsDataOutcome DcdnClient::describeDcdnDomainBpsData(const DescribeDcdnDomainBpsDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -951,6 +1095,42 @@ DcdnClient::DescribeDcdnDomainLogOutcomeCallable DcdnClient::describeDcdnDomainL
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnDomainMultiUsageDataOutcome DcdnClient::describeDcdnDomainMultiUsageData(const DescribeDcdnDomainMultiUsageDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnDomainMultiUsageDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnDomainMultiUsageDataOutcome(DescribeDcdnDomainMultiUsageDataResult(outcome.result()));
+	else
+		return DescribeDcdnDomainMultiUsageDataOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnDomainMultiUsageDataAsync(const DescribeDcdnDomainMultiUsageDataRequest& request, const DescribeDcdnDomainMultiUsageDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnDomainMultiUsageData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnDomainMultiUsageDataOutcomeCallable DcdnClient::describeDcdnDomainMultiUsageDataCallable(const DescribeDcdnDomainMultiUsageDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnDomainMultiUsageDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnDomainMultiUsageData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnDomainOriginBpsDataOutcome DcdnClient::describeDcdnDomainOriginBpsData(const DescribeDcdnDomainOriginBpsDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1347,6 +1527,42 @@ DcdnClient::DescribeDcdnDomainRealTimeSrcBpsDataOutcomeCallable DcdnClient::desc
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcome DcdnClient::describeDcdnDomainRealTimeSrcHttpCodeData(const DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcome(DescribeDcdnDomainRealTimeSrcHttpCodeDataResult(outcome.result()));
+	else
+		return DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnDomainRealTimeSrcHttpCodeDataAsync(const DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest& request, const DescribeDcdnDomainRealTimeSrcHttpCodeDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnDomainRealTimeSrcHttpCodeData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcomeCallable DcdnClient::describeDcdnDomainRealTimeSrcHttpCodeDataCallable(const DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnDomainRealTimeSrcHttpCodeDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnDomainRealTimeSrcHttpCodeData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnDomainRealTimeSrcTrafficDataOutcome DcdnClient::describeDcdnDomainRealTimeSrcTrafficData(const DescribeDcdnDomainRealTimeSrcTrafficDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1419,6 +1635,42 @@ DcdnClient::DescribeDcdnDomainRegionDataOutcomeCallable DcdnClient::describeDcdn
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnDomainStagingConfigOutcome DcdnClient::describeDcdnDomainStagingConfig(const DescribeDcdnDomainStagingConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnDomainStagingConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnDomainStagingConfigOutcome(DescribeDcdnDomainStagingConfigResult(outcome.result()));
+	else
+		return DescribeDcdnDomainStagingConfigOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnDomainStagingConfigAsync(const DescribeDcdnDomainStagingConfigRequest& request, const DescribeDcdnDomainStagingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnDomainStagingConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnDomainStagingConfigOutcomeCallable DcdnClient::describeDcdnDomainStagingConfigCallable(const DescribeDcdnDomainStagingConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnDomainStagingConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnDomainStagingConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnDomainTopReferVisitOutcome DcdnClient::describeDcdnDomainTopReferVisit(const DescribeDcdnDomainTopReferVisitRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1707,6 +1959,42 @@ DcdnClient::DescribeDcdnHttpsDomainListOutcomeCallable DcdnClient::describeDcdnH
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnIpInfoOutcome DcdnClient::describeDcdnIpInfo(const DescribeDcdnIpInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnIpInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnIpInfoOutcome(DescribeDcdnIpInfoResult(outcome.result()));
+	else
+		return DescribeDcdnIpInfoOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnIpInfoAsync(const DescribeDcdnIpInfoRequest& request, const DescribeDcdnIpInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnIpInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnIpInfoOutcomeCallable DcdnClient::describeDcdnIpInfoCallable(const DescribeDcdnIpInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnIpInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnIpInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnIpaDomainConfigsOutcome DcdnClient::describeDcdnIpaDomainConfigs(const DescribeDcdnIpaDomainConfigsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1959,6 +2247,78 @@ DcdnClient::DescribeDcdnServiceOutcomeCallable DcdnClient::describeDcdnServiceCa
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnStagingIpOutcome DcdnClient::describeDcdnStagingIp(const DescribeDcdnStagingIpRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnStagingIpOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnStagingIpOutcome(DescribeDcdnStagingIpResult(outcome.result()));
+	else
+		return DescribeDcdnStagingIpOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnStagingIpAsync(const DescribeDcdnStagingIpRequest& request, const DescribeDcdnStagingIpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnStagingIp(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnStagingIpOutcomeCallable DcdnClient::describeDcdnStagingIpCallable(const DescribeDcdnStagingIpRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnStagingIpOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnStagingIp(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DcdnClient::DescribeDcdnTagResourcesOutcome DcdnClient::describeDcdnTagResources(const DescribeDcdnTagResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnTagResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnTagResourcesOutcome(DescribeDcdnTagResourcesResult(outcome.result()));
+	else
+		return DescribeDcdnTagResourcesOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnTagResourcesAsync(const DescribeDcdnTagResourcesRequest& request, const DescribeDcdnTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnTagResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnTagResourcesOutcomeCallable DcdnClient::describeDcdnTagResourcesCallable(const DescribeDcdnTagResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnTagResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnTagResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnTopDomainsByFlowOutcome DcdnClient::describeDcdnTopDomainsByFlow(const DescribeDcdnTopDomainsByFlowRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1995,6 +2355,42 @@ DcdnClient::DescribeDcdnTopDomainsByFlowOutcomeCallable DcdnClient::describeDcdn
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnUserBillTypeOutcome DcdnClient::describeDcdnUserBillType(const DescribeDcdnUserBillTypeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnUserBillTypeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnUserBillTypeOutcome(DescribeDcdnUserBillTypeResult(outcome.result()));
+	else
+		return DescribeDcdnUserBillTypeOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnUserBillTypeAsync(const DescribeDcdnUserBillTypeRequest& request, const DescribeDcdnUserBillTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnUserBillType(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnUserBillTypeOutcomeCallable DcdnClient::describeDcdnUserBillTypeCallable(const DescribeDcdnUserBillTypeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnUserBillTypeOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnUserBillType(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeDcdnUserDomainsOutcome DcdnClient::describeDcdnUserDomains(const DescribeDcdnUserDomainsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2103,6 +2499,42 @@ DcdnClient::DescribeDcdnUserResourcePackageOutcomeCallable DcdnClient::describeD
 	return task->get_future();
 }
 
+DcdnClient::DescribeDcdnUserTagsOutcome DcdnClient::describeDcdnUserTags(const DescribeDcdnUserTagsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDcdnUserTagsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDcdnUserTagsOutcome(DescribeDcdnUserTagsResult(outcome.result()));
+	else
+		return DescribeDcdnUserTagsOutcome(outcome.error());
+}
+
+void DcdnClient::describeDcdnUserTagsAsync(const DescribeDcdnUserTagsRequest& request, const DescribeDcdnUserTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDcdnUserTags(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::DescribeDcdnUserTagsOutcomeCallable DcdnClient::describeDcdnUserTagsCallable(const DescribeDcdnUserTagsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDcdnUserTagsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDcdnUserTags(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::DescribeUserDcdnIpaStatusOutcome DcdnClient::describeUserDcdnIpaStatus(const DescribeUserDcdnIpaStatusRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2247,6 +2679,42 @@ DcdnClient::PreloadDcdnObjectCachesOutcomeCallable DcdnClient::preloadDcdnObject
 	return task->get_future();
 }
 
+DcdnClient::PublishDcdnStagingConfigToProductionOutcome DcdnClient::publishDcdnStagingConfigToProduction(const PublishDcdnStagingConfigToProductionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PublishDcdnStagingConfigToProductionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PublishDcdnStagingConfigToProductionOutcome(PublishDcdnStagingConfigToProductionResult(outcome.result()));
+	else
+		return PublishDcdnStagingConfigToProductionOutcome(outcome.error());
+}
+
+void DcdnClient::publishDcdnStagingConfigToProductionAsync(const PublishDcdnStagingConfigToProductionRequest& request, const PublishDcdnStagingConfigToProductionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, publishDcdnStagingConfigToProduction(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::PublishDcdnStagingConfigToProductionOutcomeCallable DcdnClient::publishDcdnStagingConfigToProductionCallable(const PublishDcdnStagingConfigToProductionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PublishDcdnStagingConfigToProductionOutcome()>>(
+			[this, request]()
+			{
+			return this->publishDcdnStagingConfigToProduction(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::RefreshDcdnObjectCachesOutcome DcdnClient::refreshDcdnObjectCaches(const RefreshDcdnObjectCachesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2283,6 +2751,78 @@ DcdnClient::RefreshDcdnObjectCachesOutcomeCallable DcdnClient::refreshDcdnObject
 	return task->get_future();
 }
 
+DcdnClient::RollbackDcdnStagingConfigOutcome DcdnClient::rollbackDcdnStagingConfig(const RollbackDcdnStagingConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RollbackDcdnStagingConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RollbackDcdnStagingConfigOutcome(RollbackDcdnStagingConfigResult(outcome.result()));
+	else
+		return RollbackDcdnStagingConfigOutcome(outcome.error());
+}
+
+void DcdnClient::rollbackDcdnStagingConfigAsync(const RollbackDcdnStagingConfigRequest& request, const RollbackDcdnStagingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, rollbackDcdnStagingConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::RollbackDcdnStagingConfigOutcomeCallable DcdnClient::rollbackDcdnStagingConfigCallable(const RollbackDcdnStagingConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RollbackDcdnStagingConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->rollbackDcdnStagingConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DcdnClient::SetDcdnConfigOfVersionOutcome DcdnClient::setDcdnConfigOfVersion(const SetDcdnConfigOfVersionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetDcdnConfigOfVersionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetDcdnConfigOfVersionOutcome(SetDcdnConfigOfVersionResult(outcome.result()));
+	else
+		return SetDcdnConfigOfVersionOutcome(outcome.error());
+}
+
+void DcdnClient::setDcdnConfigOfVersionAsync(const SetDcdnConfigOfVersionRequest& request, const SetDcdnConfigOfVersionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setDcdnConfigOfVersion(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::SetDcdnConfigOfVersionOutcomeCallable DcdnClient::setDcdnConfigOfVersionCallable(const SetDcdnConfigOfVersionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetDcdnConfigOfVersionOutcome()>>(
+			[this, request]()
+			{
+			return this->setDcdnConfigOfVersion(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::SetDcdnDomainCertificateOutcome DcdnClient::setDcdnDomainCertificate(const SetDcdnDomainCertificateRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2319,6 +2859,42 @@ DcdnClient::SetDcdnDomainCertificateOutcomeCallable DcdnClient::setDcdnDomainCer
 	return task->get_future();
 }
 
+DcdnClient::SetDcdnDomainStagingConfigOutcome DcdnClient::setDcdnDomainStagingConfig(const SetDcdnDomainStagingConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetDcdnDomainStagingConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetDcdnDomainStagingConfigOutcome(SetDcdnDomainStagingConfigResult(outcome.result()));
+	else
+		return SetDcdnDomainStagingConfigOutcome(outcome.error());
+}
+
+void DcdnClient::setDcdnDomainStagingConfigAsync(const SetDcdnDomainStagingConfigRequest& request, const SetDcdnDomainStagingConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setDcdnDomainStagingConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::SetDcdnDomainStagingConfigOutcomeCallable DcdnClient::setDcdnDomainStagingConfigCallable(const SetDcdnDomainStagingConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetDcdnDomainStagingConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->setDcdnDomainStagingConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::StartDcdnDomainOutcome DcdnClient::startDcdnDomain(const StartDcdnDomainRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2463,6 +3039,78 @@ DcdnClient::StopDcdnIpaDomainOutcomeCallable DcdnClient::stopDcdnIpaDomainCallab
 	return task->get_future();
 }
 
+DcdnClient::TagDcdnResourcesOutcome DcdnClient::tagDcdnResources(const TagDcdnResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TagDcdnResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TagDcdnResourcesOutcome(TagDcdnResourcesResult(outcome.result()));
+	else
+		return TagDcdnResourcesOutcome(outcome.error());
+}
+
+void DcdnClient::tagDcdnResourcesAsync(const TagDcdnResourcesRequest& request, const TagDcdnResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, tagDcdnResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::TagDcdnResourcesOutcomeCallable DcdnClient::tagDcdnResourcesCallable(const TagDcdnResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TagDcdnResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->tagDcdnResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+DcdnClient::UntagDcdnResourcesOutcome DcdnClient::untagDcdnResources(const UntagDcdnResourcesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UntagDcdnResourcesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UntagDcdnResourcesOutcome(UntagDcdnResourcesResult(outcome.result()));
+	else
+		return UntagDcdnResourcesOutcome(outcome.error());
+}
+
+void DcdnClient::untagDcdnResourcesAsync(const UntagDcdnResourcesRequest& request, const UntagDcdnResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, untagDcdnResources(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+DcdnClient::UntagDcdnResourcesOutcomeCallable DcdnClient::untagDcdnResourcesCallable(const UntagDcdnResourcesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UntagDcdnResourcesOutcome()>>(
+			[this, request]()
+			{
+			return this->untagDcdnResources(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 DcdnClient::UpdateDcdnDomainOutcome DcdnClient::updateDcdnDomain(const UpdateDcdnDomainRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

dcdn/src/model/DeleteDcdnSpecificStagingConfigRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/dcdn/model/DeleteDcdnSpecificStagingConfigRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DeleteDcdnSpecificStagingConfigRequest;
+
+DeleteDcdnSpecificStagingConfigRequest::DeleteDcdnSpecificStagingConfigRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DeleteDcdnSpecificStagingConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDcdnSpecificStagingConfigRequest::~DeleteDcdnSpecificStagingConfigRequest()
+{}
+
+std::string DeleteDcdnSpecificStagingConfigRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DeleteDcdnSpecificStagingConfigRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DeleteDcdnSpecificStagingConfigRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DeleteDcdnSpecificStagingConfigRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long DeleteDcdnSpecificStagingConfigRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteDcdnSpecificStagingConfigRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteDcdnSpecificStagingConfigRequest::getConfigId()const
+{
+	return configId_;
+}
+
+void DeleteDcdnSpecificStagingConfigRequest::setConfigId(const std::string& configId)
+{
+	configId_ = configId;
+	setParameter("ConfigId", configId);
+}
+

dcdn/src/model/DeleteDcdnSpecificStagingConfigResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DeleteDcdnSpecificStagingConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DeleteDcdnSpecificStagingConfigResult::DeleteDcdnSpecificStagingConfigResult() :
+	ServiceResult()
+{}
+
+DeleteDcdnSpecificStagingConfigResult::DeleteDcdnSpecificStagingConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteDcdnSpecificStagingConfigResult::~DeleteDcdnSpecificStagingConfigResult()
+{}
+
+void DeleteDcdnSpecificStagingConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

dcdn/src/model/DescribeDcdnBgpBpsDataRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnBgpBpsDataRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnBgpBpsDataRequest;
+
+DescribeDcdnBgpBpsDataRequest::DescribeDcdnBgpBpsDataRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnBgpBpsData")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnBgpBpsDataRequest::~DescribeDcdnBgpBpsDataRequest()
+{}
+
+std::string DescribeDcdnBgpBpsDataRequest::getIsp()const
+{
+	return isp_;
+}
+
+void DescribeDcdnBgpBpsDataRequest::setIsp(const std::string& isp)
+{
+	isp_ = isp;
+	setParameter("Isp", isp);
+}
+
+std::string DescribeDcdnBgpBpsDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeDcdnBgpBpsDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeDcdnBgpBpsDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDcdnBgpBpsDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeDcdnBgpBpsDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnBgpBpsDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDcdnBgpBpsDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeDcdnBgpBpsDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+

dcdn/src/model/DescribeDcdnBgpBpsDataResult.cc

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnBgpBpsDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnBgpBpsDataResult::DescribeDcdnBgpBpsDataResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnBgpBpsDataResult::DescribeDcdnBgpBpsDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnBgpBpsDataResult::~DescribeDcdnBgpBpsDataResult()
+{}
+
+void DescribeDcdnBgpBpsDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allBgpDataIntervalNode = value["BgpDataInterval"]["BgpData"];
+	for (auto valueBgpDataIntervalBgpData : allBgpDataIntervalNode)
+	{
+		BgpData bgpDataIntervalObject;
+		if(!valueBgpDataIntervalBgpData["In"].isNull())
+			bgpDataIntervalObject.in = std::stof(valueBgpDataIntervalBgpData["In"].asString());
+		if(!valueBgpDataIntervalBgpData["Out"].isNull())
+			bgpDataIntervalObject.out = std::stof(valueBgpDataIntervalBgpData["Out"].asString());
+		if(!valueBgpDataIntervalBgpData["TimeStamp"].isNull())
+			bgpDataIntervalObject.timeStamp = valueBgpDataIntervalBgpData["TimeStamp"].asString();
+		bgpDataInterval_.push_back(bgpDataIntervalObject);
+	}
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+
+}
+
+std::string DescribeDcdnBgpBpsDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeDcdnBgpBpsDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::vector<DescribeDcdnBgpBpsDataResult::BgpData> DescribeDcdnBgpBpsDataResult::getBgpDataInterval()const
+{
+	return bgpDataInterval_;
+}
+

dcdn/src/model/DescribeDcdnBgpTrafficDataRequest.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnBgpTrafficDataRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnBgpTrafficDataRequest;
+
+DescribeDcdnBgpTrafficDataRequest::DescribeDcdnBgpTrafficDataRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnBgpTrafficData")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnBgpTrafficDataRequest::~DescribeDcdnBgpTrafficDataRequest()
+{}
+
+std::string DescribeDcdnBgpTrafficDataRequest::getIsp()const
+{
+	return isp_;
+}
+
+void DescribeDcdnBgpTrafficDataRequest::setIsp(const std::string& isp)
+{
+	isp_ = isp;
+	setParameter("Isp", isp);
+}
+
+std::string DescribeDcdnBgpTrafficDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeDcdnBgpTrafficDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeDcdnBgpTrafficDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDcdnBgpTrafficDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeDcdnBgpTrafficDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnBgpTrafficDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDcdnBgpTrafficDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeDcdnBgpTrafficDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+

dcdn/src/model/DescribeDcdnBgpTrafficDataResult.cc

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnBgpTrafficDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnBgpTrafficDataResult::DescribeDcdnBgpTrafficDataResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnBgpTrafficDataResult::DescribeDcdnBgpTrafficDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnBgpTrafficDataResult::~DescribeDcdnBgpTrafficDataResult()
+{}
+
+void DescribeDcdnBgpTrafficDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allBgpDataIntervalNode = value["BgpDataInterval"]["BgpData"];
+	for (auto valueBgpDataIntervalBgpData : allBgpDataIntervalNode)
+	{
+		BgpData bgpDataIntervalObject;
+		if(!valueBgpDataIntervalBgpData["In"].isNull())
+			bgpDataIntervalObject.in = std::stol(valueBgpDataIntervalBgpData["In"].asString());
+		if(!valueBgpDataIntervalBgpData["Out"].isNull())
+			bgpDataIntervalObject.out = std::stol(valueBgpDataIntervalBgpData["Out"].asString());
+		if(!valueBgpDataIntervalBgpData["TimeStamp"].isNull())
+			bgpDataIntervalObject.timeStamp = valueBgpDataIntervalBgpData["TimeStamp"].asString();
+		bgpDataInterval_.push_back(bgpDataIntervalObject);
+	}
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+
+}
+
+std::string DescribeDcdnBgpTrafficDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeDcdnBgpTrafficDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::vector<DescribeDcdnBgpTrafficDataResult::BgpData> DescribeDcdnBgpTrafficDataResult::getBgpDataInterval()const
+{
+	return bgpDataInterval_;
+}
+

dcdn/src/model/DescribeDcdnConfigOfVersionRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeDcdnConfigOfVersionRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnConfigOfVersionRequest;
+
+DescribeDcdnConfigOfVersionRequest::DescribeDcdnConfigOfVersionRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnConfigOfVersion")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnConfigOfVersionRequest::~DescribeDcdnConfigOfVersionRequest()
+{}
+
+std::string DescribeDcdnConfigOfVersionRequest::getVersionId()const
+{
+	return versionId_;
+}
+
+void DescribeDcdnConfigOfVersionRequest::setVersionId(const std::string& versionId)
+{
+	versionId_ = versionId;
+	setParameter("VersionId", versionId);
+}
+
+std::string DescribeDcdnConfigOfVersionRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeDcdnConfigOfVersionRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeDcdnConfigOfVersionRequest::getFunctionName()const
+{
+	return functionName_;
+}
+
+void DescribeDcdnConfigOfVersionRequest::setFunctionName(const std::string& functionName)
+{
+	functionName_ = functionName;
+	setParameter("FunctionName", functionName);
+}
+
+long DescribeDcdnConfigOfVersionRequest::getGroupId()const
+{
+	return groupId_;
+}
+
+void DescribeDcdnConfigOfVersionRequest::setGroupId(long groupId)
+{
+	groupId_ = groupId;
+	setParameter("GroupId", std::to_string(groupId));
+}
+
+long DescribeDcdnConfigOfVersionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnConfigOfVersionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+int DescribeDcdnConfigOfVersionRequest::getFunctionId()const
+{
+	return functionId_;
+}
+
+void DescribeDcdnConfigOfVersionRequest::setFunctionId(int functionId)
+{
+	functionId_ = functionId;
+	setParameter("FunctionId", std::to_string(functionId));
+}
+

dcdn/src/model/DescribeDcdnConfigOfVersionResult.cc

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnConfigOfVersionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnConfigOfVersionResult::DescribeDcdnConfigOfVersionResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnConfigOfVersionResult::DescribeDcdnConfigOfVersionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnConfigOfVersionResult::~DescribeDcdnConfigOfVersionResult()
+{}
+
+void DescribeDcdnConfigOfVersionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allVersionConfigsNode = value["VersionConfigs"]["VersionConfig"];
+	for (auto valueVersionConfigsVersionConfig : allVersionConfigsNode)
+	{
+		VersionConfig versionConfigsObject;
+		if(!valueVersionConfigsVersionConfig["Status"].isNull())
+			versionConfigsObject.status = valueVersionConfigsVersionConfig["Status"].asString();
+		if(!valueVersionConfigsVersionConfig["ConfigId"].isNull())
+			versionConfigsObject.configId = valueVersionConfigsVersionConfig["ConfigId"].asString();
+		if(!valueVersionConfigsVersionConfig["FunctionName"].isNull())
+			versionConfigsObject.functionName = valueVersionConfigsVersionConfig["FunctionName"].asString();
+		auto allFunctionArgsNode = allVersionConfigsNode["FunctionArgs"]["FunctionArg"];
+		for (auto allVersionConfigsNodeFunctionArgsFunctionArg : allFunctionArgsNode)
+		{
+			VersionConfig::FunctionArg functionArgsObject;
+			if(!allVersionConfigsNodeFunctionArgsFunctionArg["ArgName"].isNull())
+				functionArgsObject.argName = allVersionConfigsNodeFunctionArgsFunctionArg["ArgName"].asString();
+			if(!allVersionConfigsNodeFunctionArgsFunctionArg["ArgValue"].isNull())
+				functionArgsObject.argValue = allVersionConfigsNodeFunctionArgsFunctionArg["ArgValue"].asString();
+			versionConfigsObject.functionArgs.push_back(functionArgsObject);
+		}
+		versionConfigs_.push_back(versionConfigsObject);
+	}
+
+}
+
+std::vector<DescribeDcdnConfigOfVersionResult::VersionConfig> DescribeDcdnConfigOfVersionResult::getVersionConfigs()const
+{
+	return versionConfigs_;
+}
+

dcdn/src/model/DescribeDcdnDomainMultiUsageDataRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnDomainMultiUsageDataRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnDomainMultiUsageDataRequest;
+
+DescribeDcdnDomainMultiUsageDataRequest::DescribeDcdnDomainMultiUsageDataRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnDomainMultiUsageData")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnDomainMultiUsageDataRequest::~DescribeDcdnDomainMultiUsageDataRequest()
+{}
+
+std::string DescribeDcdnDomainMultiUsageDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeDcdnDomainMultiUsageDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeDcdnDomainMultiUsageDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeDcdnDomainMultiUsageDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeDcdnDomainMultiUsageDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDcdnDomainMultiUsageDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeDcdnDomainMultiUsageDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnDomainMultiUsageDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dcdn/src/model/DescribeDcdnDomainMultiUsageDataResult.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/DescribeDcdnDomainMultiUsageDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnDomainMultiUsageDataResult::DescribeDcdnDomainMultiUsageDataResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnDomainMultiUsageDataResult::DescribeDcdnDomainMultiUsageDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnDomainMultiUsageDataResult::~DescribeDcdnDomainMultiUsageDataResult()
+{}
+
+void DescribeDcdnDomainMultiUsageDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRequestPerIntervalNode = value["RequestPerInterval"]["RequestDataModule"];
+	for (auto valueRequestPerIntervalRequestDataModule : allRequestPerIntervalNode)
+	{
+		RequestDataModule requestPerIntervalObject;
+		if(!valueRequestPerIntervalRequestDataModule["TimeStamp"].isNull())
+			requestPerIntervalObject.timeStamp = valueRequestPerIntervalRequestDataModule["TimeStamp"].asString();
+		if(!valueRequestPerIntervalRequestDataModule["Domain"].isNull())
+			requestPerIntervalObject.domain = valueRequestPerIntervalRequestDataModule["Domain"].asString();
+		if(!valueRequestPerIntervalRequestDataModule["Request"].isNull())
+			requestPerIntervalObject.request = std::stol(valueRequestPerIntervalRequestDataModule["Request"].asString());
+		if(!valueRequestPerIntervalRequestDataModule["Type"].isNull())
+			requestPerIntervalObject.type = valueRequestPerIntervalRequestDataModule["Type"].asString();
+		requestPerInterval_.push_back(requestPerIntervalObject);
+	}
+	auto allTrafficPerIntervalNode = value["TrafficPerInterval"]["TrafficDataModule"];
+	for (auto valueTrafficPerIntervalTrafficDataModule : allTrafficPerIntervalNode)
+	{
+		TrafficDataModule trafficPerIntervalObject;
+		if(!valueTrafficPerIntervalTrafficDataModule["TimeStamp"].isNull())
+			trafficPerIntervalObject.timeStamp = valueTrafficPerIntervalTrafficDataModule["TimeStamp"].asString();
+		if(!valueTrafficPerIntervalTrafficDataModule["Domain"].isNull())
+			trafficPerIntervalObject.domain = valueTrafficPerIntervalTrafficDataModule["Domain"].asString();
+		if(!valueTrafficPerIntervalTrafficDataModule["Bps"].isNull())
+			trafficPerIntervalObject.bps = std::stof(valueTrafficPerIntervalTrafficDataModule["Bps"].asString());
+		if(!valueTrafficPerIntervalTrafficDataModule["Type"].isNull())
+			trafficPerIntervalObject.type = valueTrafficPerIntervalTrafficDataModule["Type"].asString();
+		if(!valueTrafficPerIntervalTrafficDataModule["Area"].isNull())
+			trafficPerIntervalObject.area = valueTrafficPerIntervalTrafficDataModule["Area"].asString();
+		trafficPerInterval_.push_back(trafficPerIntervalObject);
+	}
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+
+}
+
+std::string DescribeDcdnDomainMultiUsageDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeDcdnDomainMultiUsageDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::vector<DescribeDcdnDomainMultiUsageDataResult::RequestDataModule> DescribeDcdnDomainMultiUsageDataResult::getRequestPerInterval()const
+{
+	return requestPerInterval_;
+}
+
+std::vector<DescribeDcdnDomainMultiUsageDataResult::TrafficDataModule> DescribeDcdnDomainMultiUsageDataResult::getTrafficPerInterval()const
+{
+	return trafficPerInterval_;
+}
+

dcdn/src/model/DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest;
+
+DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnDomainRealTimeSrcHttpCodeData")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::~DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest()
+{}
+
+std::string DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::getLocationNameEn()const
+{
+	return locationNameEn_;
+}
+
+void DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::setLocationNameEn(const std::string& locationNameEn)
+{
+	locationNameEn_ = locationNameEn;
+	setParameter("LocationNameEn", locationNameEn);
+}
+
+std::string DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::getIspNameEn()const
+{
+	return ispNameEn_;
+}
+
+void DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::setIspNameEn(const std::string& ispNameEn)
+{
+	ispNameEn_ = ispNameEn;
+	setParameter("IspNameEn", ispNameEn);
+}
+
+std::string DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnDomainRealTimeSrcHttpCodeDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dcdn/src/model/DescribeDcdnDomainRealTimeSrcHttpCodeDataResult.cc

@@ -0,0 +1,97 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeDcdnDomainRealTimeSrcHttpCodeDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnDomainRealTimeSrcHttpCodeDataResult::DescribeDcdnDomainRealTimeSrcHttpCodeDataResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnDomainRealTimeSrcHttpCodeDataResult::DescribeDcdnDomainRealTimeSrcHttpCodeDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnDomainRealTimeSrcHttpCodeDataResult::~DescribeDcdnDomainRealTimeSrcHttpCodeDataResult()
+{}
+
+void DescribeDcdnDomainRealTimeSrcHttpCodeDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRealTimeSrcHttpCodeDataNode = value["RealTimeSrcHttpCodeData"]["UsageData"];
+	for (auto valueRealTimeSrcHttpCodeDataUsageData : allRealTimeSrcHttpCodeDataNode)
+	{
+		UsageData realTimeSrcHttpCodeDataObject;
+		if(!valueRealTimeSrcHttpCodeDataUsageData["TimeStamp"].isNull())
+			realTimeSrcHttpCodeDataObject.timeStamp = valueRealTimeSrcHttpCodeDataUsageData["TimeStamp"].asString();
+		auto allValueNode = allRealTimeSrcHttpCodeDataNode["Value"]["RealTimeSrcCodeProportionData"];
+		for (auto allRealTimeSrcHttpCodeDataNodeValueRealTimeSrcCodeProportionData : allValueNode)
+		{
+			UsageData::RealTimeSrcCodeProportionData valueObject;
+			if(!allRealTimeSrcHttpCodeDataNodeValueRealTimeSrcCodeProportionData["Code"].isNull())
+				valueObject.code = allRealTimeSrcHttpCodeDataNodeValueRealTimeSrcCodeProportionData["Code"].asString();
+			if(!allRealTimeSrcHttpCodeDataNodeValueRealTimeSrcCodeProportionData["Proportion"].isNull())
+				valueObject.proportion = allRealTimeSrcHttpCodeDataNodeValueRealTimeSrcCodeProportionData["Proportion"].asString();
+			if(!allRealTimeSrcHttpCodeDataNodeValueRealTimeSrcCodeProportionData["Count"].isNull())
+				valueObject.count = allRealTimeSrcHttpCodeDataNodeValueRealTimeSrcCodeProportionData["Count"].asString();
+			realTimeSrcHttpCodeDataObject.value.push_back(valueObject);
+		}
+		realTimeSrcHttpCodeData_.push_back(realTimeSrcHttpCodeDataObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+
+}
+
+std::string DescribeDcdnDomainRealTimeSrcHttpCodeDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeDcdnDomainRealTimeSrcHttpCodeDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeDcdnDomainRealTimeSrcHttpCodeDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::string DescribeDcdnDomainRealTimeSrcHttpCodeDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+
+std::vector<DescribeDcdnDomainRealTimeSrcHttpCodeDataResult::UsageData> DescribeDcdnDomainRealTimeSrcHttpCodeDataResult::getRealTimeSrcHttpCodeData()const
+{
+	return realTimeSrcHttpCodeData_;
+}
+

dcdn/src/model/DescribeDcdnDomainStagingConfigRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnDomainStagingConfigRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnDomainStagingConfigRequest;
+
+DescribeDcdnDomainStagingConfigRequest::DescribeDcdnDomainStagingConfigRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnDomainStagingConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnDomainStagingConfigRequest::~DescribeDcdnDomainStagingConfigRequest()
+{}
+
+std::string DescribeDcdnDomainStagingConfigRequest::getFunctionNames()const
+{
+	return functionNames_;
+}
+
+void DescribeDcdnDomainStagingConfigRequest::setFunctionNames(const std::string& functionNames)
+{
+	functionNames_ = functionNames;
+	setParameter("FunctionNames", functionNames);
+}
+
+std::string DescribeDcdnDomainStagingConfigRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeDcdnDomainStagingConfigRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long DescribeDcdnDomainStagingConfigRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnDomainStagingConfigRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dcdn/src/model/DescribeDcdnDomainStagingConfigResult.cc

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnDomainStagingConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnDomainStagingConfigResult::DescribeDcdnDomainStagingConfigResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnDomainStagingConfigResult::DescribeDcdnDomainStagingConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnDomainStagingConfigResult::~DescribeDcdnDomainStagingConfigResult()
+{}
+
+void DescribeDcdnDomainStagingConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDomainConfigsNode = value["DomainConfigs"]["DomainConfig"];
+	for (auto valueDomainConfigsDomainConfig : allDomainConfigsNode)
+	{
+		DomainConfig domainConfigsObject;
+		if(!valueDomainConfigsDomainConfig["FunctionName"].isNull())
+			domainConfigsObject.functionName = valueDomainConfigsDomainConfig["FunctionName"].asString();
+		if(!valueDomainConfigsDomainConfig["ConfigId"].isNull())
+			domainConfigsObject.configId = valueDomainConfigsDomainConfig["ConfigId"].asString();
+		if(!valueDomainConfigsDomainConfig["Status"].isNull())
+			domainConfigsObject.status = valueDomainConfigsDomainConfig["Status"].asString();
+		auto allFunctionArgsNode = allDomainConfigsNode["FunctionArgs"]["FunctionArg"];
+		for (auto allDomainConfigsNodeFunctionArgsFunctionArg : allFunctionArgsNode)
+		{
+			DomainConfig::FunctionArg functionArgsObject;
+			if(!allDomainConfigsNodeFunctionArgsFunctionArg["ArgName"].isNull())
+				functionArgsObject.argName = allDomainConfigsNodeFunctionArgsFunctionArg["ArgName"].asString();
+			if(!allDomainConfigsNodeFunctionArgsFunctionArg["ArgValue"].isNull())
+				functionArgsObject.argValue = allDomainConfigsNodeFunctionArgsFunctionArg["ArgValue"].asString();
+			domainConfigsObject.functionArgs.push_back(functionArgsObject);
+		}
+		domainConfigs_.push_back(domainConfigsObject);
+	}
+
+}
+
+std::vector<DescribeDcdnDomainStagingConfigResult::DomainConfig> DescribeDcdnDomainStagingConfigResult::getDomainConfigs()const
+{
+	return domainConfigs_;
+}
+

dcdn/src/model/DescribeDcdnIpInfoRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnIpInfoRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnIpInfoRequest;
+
+DescribeDcdnIpInfoRequest::DescribeDcdnIpInfoRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnIpInfo")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnIpInfoRequest::~DescribeDcdnIpInfoRequest()
+{}
+
+std::string DescribeDcdnIpInfoRequest::getIP()const
+{
+	return iP_;
+}
+
+void DescribeDcdnIpInfoRequest::setIP(const std::string& iP)
+{
+	iP_ = iP;
+	setParameter("IP", iP);
+}
+
+long DescribeDcdnIpInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnIpInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDcdnIpInfoRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeDcdnIpInfoRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+

dcdn/src/model/DescribeDcdnIpInfoResult.cc

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeDcdnIpInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnIpInfoResult::DescribeDcdnIpInfoResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnIpInfoResult::DescribeDcdnIpInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnIpInfoResult::~DescribeDcdnIpInfoResult()
+{}
+
+void DescribeDcdnIpInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["DcdnIp"].isNull())
+		dcdnIp_ = value["DcdnIp"].asString();
+	if(!value["ISP"].isNull())
+		iSP_ = value["ISP"].asString();
+	if(!value["IspEname"].isNull())
+		ispEname_ = value["IspEname"].asString();
+	if(!value["Region"].isNull())
+		region_ = value["Region"].asString();
+	if(!value["RegionEname"].isNull())
+		regionEname_ = value["RegionEname"].asString();
+
+}
+
+std::string DescribeDcdnIpInfoResult::getISP()const
+{
+	return iSP_;
+}
+
+std::string DescribeDcdnIpInfoResult::getRegion()const
+{
+	return region_;
+}
+
+std::string DescribeDcdnIpInfoResult::getIspEname()const
+{
+	return ispEname_;
+}
+
+std::string DescribeDcdnIpInfoResult::getDcdnIp()const
+{
+	return dcdnIp_;
+}
+
+std::string DescribeDcdnIpInfoResult::getRegionEname()const
+{
+	return regionEname_;
+}
+

dcdn/src/model/DescribeDcdnStagingIpRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeDcdnStagingIpRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnStagingIpRequest;
+
+DescribeDcdnStagingIpRequest::DescribeDcdnStagingIpRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnStagingIp")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnStagingIpRequest::~DescribeDcdnStagingIpRequest()
+{}
+
+long DescribeDcdnStagingIpRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnStagingIpRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dcdn/src/model/DescribeDcdnStagingIpResult.cc

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeDcdnStagingIpResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnStagingIpResult::DescribeDcdnStagingIpResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnStagingIpResult::DescribeDcdnStagingIpResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnStagingIpResult::~DescribeDcdnStagingIpResult()
+{}
+
+void DescribeDcdnStagingIpResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allIPV4s = value["IPV4s"]["IPV4"];
+	for (const auto &item : allIPV4s)
+		iPV4s_.push_back(item.asString());
+
+}
+
+std::vector<std::string> DescribeDcdnStagingIpResult::getIPV4s()const
+{
+	return iPV4s_;
+}
+

dcdn/src/model/DescribeDcdnTagResourcesRequest.cc

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeDcdnTagResourcesRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnTagResourcesRequest;
+
+DescribeDcdnTagResourcesRequest::DescribeDcdnTagResourcesRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnTagResources")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnTagResourcesRequest::~DescribeDcdnTagResourcesRequest()
+{}
+
+std::string DescribeDcdnTagResourcesRequest::getScope()const
+{
+	return scope_;
+}
+
+void DescribeDcdnTagResourcesRequest::setScope(const std::string& scope)
+{
+	scope_ = scope;
+	setParameter("Scope", scope);
+}
+
+std::vector<DescribeDcdnTagResourcesRequest::Tag> DescribeDcdnTagResourcesRequest::getTag()const
+{
+	return tag_;
+}
+
+void DescribeDcdnTagResourcesRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+	}
+}
+
+std::vector<std::string> DescribeDcdnTagResourcesRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void DescribeDcdnTagResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
+{
+	resourceId_ = resourceId;
+	for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
+		setParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
+	}
+}
+
+long DescribeDcdnTagResourcesRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnTagResourcesRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDcdnTagResourcesRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void DescribeDcdnTagResourcesRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+

dcdn/src/model/DescribeDcdnTagResourcesResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnTagResourcesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnTagResourcesResult::DescribeDcdnTagResourcesResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnTagResourcesResult::DescribeDcdnTagResourcesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnTagResourcesResult::~DescribeDcdnTagResourcesResult()
+{}
+
+void DescribeDcdnTagResourcesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagResourcesNode = value["TagResources"]["TagResource"];
+	for (auto valueTagResourcesTagResource : allTagResourcesNode)
+	{
+		TagResource tagResourcesObject;
+		if(!valueTagResourcesTagResource["ResourceId"].isNull())
+			tagResourcesObject.resourceId = valueTagResourcesTagResource["ResourceId"].asString();
+		auto allTagNode = allTagResourcesNode["Tag"]["TagItem"];
+		for (auto allTagResourcesNodeTagTagItem : allTagNode)
+		{
+			TagResource::TagItem tagObject;
+			if(!allTagResourcesNodeTagTagItem["Key"].isNull())
+				tagObject.key = allTagResourcesNodeTagTagItem["Key"].asString();
+			if(!allTagResourcesNodeTagTagItem["Value"].isNull())
+				tagObject.value = allTagResourcesNodeTagTagItem["Value"].asString();
+			tagResourcesObject.tag.push_back(tagObject);
+		}
+		tagResources_.push_back(tagResourcesObject);
+	}
+
+}
+
+std::vector<DescribeDcdnTagResourcesResult::TagResource> DescribeDcdnTagResourcesResult::getTagResources()const
+{
+	return tagResources_;
+}
+

dcdn/src/model/DescribeDcdnUserBillTypeRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnUserBillTypeRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnUserBillTypeRequest;
+
+DescribeDcdnUserBillTypeRequest::DescribeDcdnUserBillTypeRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnUserBillType")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnUserBillTypeRequest::~DescribeDcdnUserBillTypeRequest()
+{}
+
+std::string DescribeDcdnUserBillTypeRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeDcdnUserBillTypeRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeDcdnUserBillTypeRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDcdnUserBillTypeRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeDcdnUserBillTypeRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnUserBillTypeRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dcdn/src/model/DescribeDcdnUserBillTypeResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/dcdn/model/DescribeDcdnUserBillTypeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnUserBillTypeResult::DescribeDcdnUserBillTypeResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnUserBillTypeResult::DescribeDcdnUserBillTypeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnUserBillTypeResult::~DescribeDcdnUserBillTypeResult()
+{}
+
+void DescribeDcdnUserBillTypeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allBillTypeDataNode = value["BillTypeData"]["BillTypeDataItem"];
+	for (auto valueBillTypeDataBillTypeDataItem : allBillTypeDataNode)
+	{
+		BillTypeDataItem billTypeDataObject;
+		if(!valueBillTypeDataBillTypeDataItem["StartTime"].isNull())
+			billTypeDataObject.startTime = valueBillTypeDataBillTypeDataItem["StartTime"].asString();
+		if(!valueBillTypeDataBillTypeDataItem["EndTime"].isNull())
+			billTypeDataObject.endTime = valueBillTypeDataBillTypeDataItem["EndTime"].asString();
+		if(!valueBillTypeDataBillTypeDataItem["Product"].isNull())
+			billTypeDataObject.product = valueBillTypeDataBillTypeDataItem["Product"].asString();
+		if(!valueBillTypeDataBillTypeDataItem["Dimension"].isNull())
+			billTypeDataObject.dimension = valueBillTypeDataBillTypeDataItem["Dimension"].asString();
+		if(!valueBillTypeDataBillTypeDataItem["BillType"].isNull())
+			billTypeDataObject.billType = valueBillTypeDataBillTypeDataItem["BillType"].asString();
+		if(!valueBillTypeDataBillTypeDataItem["BillingCycle"].isNull())
+			billTypeDataObject.billingCycle = valueBillTypeDataBillTypeDataItem["BillingCycle"].asString();
+		billTypeData_.push_back(billTypeDataObject);
+	}
+
+}
+
+std::vector<DescribeDcdnUserBillTypeResult::BillTypeDataItem> DescribeDcdnUserBillTypeResult::getBillTypeData()const
+{
+	return billTypeData_;
+}
+

dcdn/src/model/DescribeDcdnUserTagsRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/DescribeDcdnUserTagsRequest.h>
+
+using AlibabaCloud::Dcdn::Model::DescribeDcdnUserTagsRequest;
+
+DescribeDcdnUserTagsRequest::DescribeDcdnUserTagsRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "DescribeDcdnUserTags")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDcdnUserTagsRequest::~DescribeDcdnUserTagsRequest()
+{}
+
+long DescribeDcdnUserTagsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDcdnUserTagsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dcdn/src/model/DescribeDcdnUserTagsResult.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/DescribeDcdnUserTagsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+DescribeDcdnUserTagsResult::DescribeDcdnUserTagsResult() :
+	ServiceResult()
+{}
+
+DescribeDcdnUserTagsResult::DescribeDcdnUserTagsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDcdnUserTagsResult::~DescribeDcdnUserTagsResult()
+{}
+
+void DescribeDcdnUserTagsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTagsNode = value["Tags"]["Tag"];
+	for (auto valueTagsTag : allTagsNode)
+	{
+		Tag tagsObject;
+		if(!valueTagsTag["Key"].isNull())
+			tagsObject.key = valueTagsTag["Key"].asString();
+		auto allValue = value["Value"]["Value"];
+		for (auto value : allValue)
+			tagsObject.value.push_back(value.asString());
+		tags_.push_back(tagsObject);
+	}
+
+}
+
+std::vector<DescribeDcdnUserTagsResult::Tag> DescribeDcdnUserTagsResult::getTags()const
+{
+	return tags_;
+}
+

dcdn/src/model/PublishDcdnStagingConfigToProductionRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/PublishDcdnStagingConfigToProductionRequest.h>
+
+using AlibabaCloud::Dcdn::Model::PublishDcdnStagingConfigToProductionRequest;
+
+PublishDcdnStagingConfigToProductionRequest::PublishDcdnStagingConfigToProductionRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "PublishDcdnStagingConfigToProduction")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+PublishDcdnStagingConfigToProductionRequest::~PublishDcdnStagingConfigToProductionRequest()
+{}
+
+std::string PublishDcdnStagingConfigToProductionRequest::getFunctionName()const
+{
+	return functionName_;
+}
+
+void PublishDcdnStagingConfigToProductionRequest::setFunctionName(const std::string& functionName)
+{
+	functionName_ = functionName;
+	setParameter("FunctionName", functionName);
+}
+
+std::string PublishDcdnStagingConfigToProductionRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void PublishDcdnStagingConfigToProductionRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long PublishDcdnStagingConfigToProductionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void PublishDcdnStagingConfigToProductionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dcdn/src/model/PublishDcdnStagingConfigToProductionResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/PublishDcdnStagingConfigToProductionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+PublishDcdnStagingConfigToProductionResult::PublishDcdnStagingConfigToProductionResult() :
+	ServiceResult()
+{}
+
+PublishDcdnStagingConfigToProductionResult::PublishDcdnStagingConfigToProductionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+PublishDcdnStagingConfigToProductionResult::~PublishDcdnStagingConfigToProductionResult()
+{}
+
+void PublishDcdnStagingConfigToProductionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

dcdn/src/model/RollbackDcdnStagingConfigRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/RollbackDcdnStagingConfigRequest.h>
+
+using AlibabaCloud::Dcdn::Model::RollbackDcdnStagingConfigRequest;
+
+RollbackDcdnStagingConfigRequest::RollbackDcdnStagingConfigRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "RollbackDcdnStagingConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+RollbackDcdnStagingConfigRequest::~RollbackDcdnStagingConfigRequest()
+{}
+
+std::string RollbackDcdnStagingConfigRequest::getFunctionName()const
+{
+	return functionName_;
+}
+
+void RollbackDcdnStagingConfigRequest::setFunctionName(const std::string& functionName)
+{
+	functionName_ = functionName;
+	setParameter("FunctionName", functionName);
+}
+
+std::string RollbackDcdnStagingConfigRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void RollbackDcdnStagingConfigRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long RollbackDcdnStagingConfigRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void RollbackDcdnStagingConfigRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dcdn/src/model/RollbackDcdnStagingConfigResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/RollbackDcdnStagingConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+RollbackDcdnStagingConfigResult::RollbackDcdnStagingConfigResult() :
+	ServiceResult()
+{}
+
+RollbackDcdnStagingConfigResult::RollbackDcdnStagingConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+RollbackDcdnStagingConfigResult::~RollbackDcdnStagingConfigResult()
+{}
+
+void RollbackDcdnStagingConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

dcdn/src/model/SetDcdnConfigOfVersionRequest.cc

@@ -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.
+ */
+
+#include <alibabacloud/dcdn/model/SetDcdnConfigOfVersionRequest.h>
+
+using AlibabaCloud::Dcdn::Model::SetDcdnConfigOfVersionRequest;
+
+SetDcdnConfigOfVersionRequest::SetDcdnConfigOfVersionRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "SetDcdnConfigOfVersion")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SetDcdnConfigOfVersionRequest::~SetDcdnConfigOfVersionRequest()
+{}
+
+std::string SetDcdnConfigOfVersionRequest::getVersionId()const
+{
+	return versionId_;
+}
+
+void SetDcdnConfigOfVersionRequest::setVersionId(const std::string& versionId)
+{
+	versionId_ = versionId;
+	setParameter("VersionId", versionId);
+}
+
+std::string SetDcdnConfigOfVersionRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void SetDcdnConfigOfVersionRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string SetDcdnConfigOfVersionRequest::getFunctionName()const
+{
+	return functionName_;
+}
+
+void SetDcdnConfigOfVersionRequest::setFunctionName(const std::string& functionName)
+{
+	functionName_ = functionName;
+	setParameter("FunctionName", functionName);
+}
+
+std::string SetDcdnConfigOfVersionRequest::getFunctionArgs()const
+{
+	return functionArgs_;
+}
+
+void SetDcdnConfigOfVersionRequest::setFunctionArgs(const std::string& functionArgs)
+{
+	functionArgs_ = functionArgs;
+	setParameter("FunctionArgs", functionArgs);
+}
+
+std::string SetDcdnConfigOfVersionRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void SetDcdnConfigOfVersionRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long SetDcdnConfigOfVersionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetDcdnConfigOfVersionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+long SetDcdnConfigOfVersionRequest::getFunctionId()const
+{
+	return functionId_;
+}
+
+void SetDcdnConfigOfVersionRequest::setFunctionId(long functionId)
+{
+	functionId_ = functionId;
+	setParameter("FunctionId", std::to_string(functionId));
+}
+
+std::string SetDcdnConfigOfVersionRequest::getConfigId()const
+{
+	return configId_;
+}
+
+void SetDcdnConfigOfVersionRequest::setConfigId(const std::string& configId)
+{
+	configId_ = configId;
+	setParameter("ConfigId", configId);
+}
+

dcdn/src/model/SetDcdnConfigOfVersionResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/SetDcdnConfigOfVersionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+SetDcdnConfigOfVersionResult::SetDcdnConfigOfVersionResult() :
+	ServiceResult()
+{}
+
+SetDcdnConfigOfVersionResult::SetDcdnConfigOfVersionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetDcdnConfigOfVersionResult::~SetDcdnConfigOfVersionResult()
+{}
+
+void SetDcdnConfigOfVersionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

dcdn/src/model/SetDcdnDomainStagingConfigRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/SetDcdnDomainStagingConfigRequest.h>
+
+using AlibabaCloud::Dcdn::Model::SetDcdnDomainStagingConfigRequest;
+
+SetDcdnDomainStagingConfigRequest::SetDcdnDomainStagingConfigRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "SetDcdnDomainStagingConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SetDcdnDomainStagingConfigRequest::~SetDcdnDomainStagingConfigRequest()
+{}
+
+std::string SetDcdnDomainStagingConfigRequest::getFunctions()const
+{
+	return functions_;
+}
+
+void SetDcdnDomainStagingConfigRequest::setFunctions(const std::string& functions)
+{
+	functions_ = functions;
+	setParameter("Functions", functions);
+}
+
+std::string SetDcdnDomainStagingConfigRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void SetDcdnDomainStagingConfigRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long SetDcdnDomainStagingConfigRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetDcdnDomainStagingConfigRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

dcdn/src/model/SetDcdnDomainStagingConfigResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/scdn/model/SetDomainServerCertificateResult.h>
+#include <alibabacloud/dcdn/model/SetDcdnDomainStagingConfigResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::Scdn;
-using namespace AlibabaCloud::Scdn::Model;
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
 
-SetDomainServerCertificateResult::SetDomainServerCertificateResult() :
+SetDcdnDomainStagingConfigResult::SetDcdnDomainStagingConfigResult() :
 	ServiceResult()
 {}
 
-SetDomainServerCertificateResult::SetDomainServerCertificateResult(const std::string &payload) :
+SetDcdnDomainStagingConfigResult::SetDcdnDomainStagingConfigResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-SetDomainServerCertificateResult::~SetDomainServerCertificateResult()
+SetDcdnDomainStagingConfigResult::~SetDcdnDomainStagingConfigResult()
 {}
 
-void SetDomainServerCertificateResult::parse(const std::string &payload)
+void SetDcdnDomainStagingConfigResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;

dcdn/src/model/TagDcdnResourcesRequest.cc

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/TagDcdnResourcesRequest.h>
+
+using AlibabaCloud::Dcdn::Model::TagDcdnResourcesRequest;
+
+TagDcdnResourcesRequest::TagDcdnResourcesRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "TagDcdnResources")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+TagDcdnResourcesRequest::~TagDcdnResourcesRequest()
+{}
+
+std::string TagDcdnResourcesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void TagDcdnResourcesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::vector<TagDcdnResourcesRequest::Tag> TagDcdnResourcesRequest::getTag()const
+{
+	return tag_;
+}
+
+void TagDcdnResourcesRequest::setTag(const std::vector<Tag>& tag)
+{
+	tag_ = tag;
+	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
+		auto tagObj = tag.at(dep1);
+		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
+		setParameter(tagObjStr + ".Key", tagObj.key);
+		setParameter(tagObjStr + ".Value", tagObj.value);
+	}
+}
+
+std::vector<std::string> TagDcdnResourcesRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void TagDcdnResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
+{
+	resourceId_ = resourceId;
+	for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
+		setParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
+	}
+}
+
+long TagDcdnResourcesRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void TagDcdnResourcesRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string TagDcdnResourcesRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void TagDcdnResourcesRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+

dcdn/src/model/TagDcdnResourcesResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/TagDcdnResourcesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+TagDcdnResourcesResult::TagDcdnResourcesResult() :
+	ServiceResult()
+{}
+
+TagDcdnResourcesResult::TagDcdnResourcesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+TagDcdnResourcesResult::~TagDcdnResourcesResult()
+{}
+
+void TagDcdnResourcesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

dcdn/src/model/UntagDcdnResourcesRequest.cc

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/dcdn/model/UntagDcdnResourcesRequest.h>
+
+using AlibabaCloud::Dcdn::Model::UntagDcdnResourcesRequest;
+
+UntagDcdnResourcesRequest::UntagDcdnResourcesRequest() :
+	RpcServiceRequest("dcdn", "2018-01-15", "UntagDcdnResources")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UntagDcdnResourcesRequest::~UntagDcdnResourcesRequest()
+{}
+
+std::string UntagDcdnResourcesRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void UntagDcdnResourcesRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::vector<std::string> UntagDcdnResourcesRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void UntagDcdnResourcesRequest::setResourceId(const std::vector<std::string>& resourceId)
+{
+	resourceId_ = resourceId;
+	for(int dep1 = 0; dep1!= resourceId.size(); dep1++) {
+		setParameter("ResourceId."+ std::to_string(dep1), resourceId.at(dep1));
+	}
+}
+
+long UntagDcdnResourcesRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void UntagDcdnResourcesRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string UntagDcdnResourcesRequest::getResourceType()const
+{
+	return resourceType_;
+}
+
+void UntagDcdnResourcesRequest::setResourceType(const std::string& resourceType)
+{
+	resourceType_ = resourceType;
+	setParameter("ResourceType", resourceType);
+}
+
+std::vector<std::string> UntagDcdnResourcesRequest::getTagKey()const
+{
+	return tagKey_;
+}
+
+void UntagDcdnResourcesRequest::setTagKey(const std::vector<std::string>& tagKey)
+{
+	tagKey_ = tagKey;
+	for(int dep1 = 0; dep1!= tagKey.size(); dep1++) {
+		setParameter("TagKey."+ std::to_string(dep1), tagKey.at(dep1));
+	}
+}
+

dcdn/src/model/UntagDcdnResourcesResult.cc

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/UntagDcdnResourcesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Dcdn;
+using namespace AlibabaCloud::Dcdn::Model;
+
+UntagDcdnResourcesResult::UntagDcdnResourcesResult() :
+	ServiceResult()
+{}
+
+UntagDcdnResourcesResult::UntagDcdnResourcesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+UntagDcdnResourcesResult::~UntagDcdnResourcesResult()
+{}
+
+void UntagDcdnResourcesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

facebody/CMakeLists.txt

@@ -43,6 +43,8 @@ set(facebody_public_header_model
 	include/alibabacloud/facebody/model/DetectBodyCountResult.h
 	include/alibabacloud/facebody/model/DetectCelebrityRequest.h
 	include/alibabacloud/facebody/model/DetectCelebrityResult.h
+	include/alibabacloud/facebody/model/DetectChefCapRequest.h
+	include/alibabacloud/facebody/model/DetectChefCapResult.h
 	include/alibabacloud/facebody/model/DetectFaceRequest.h
 	include/alibabacloud/facebody/model/DetectFaceResult.h
 	include/alibabacloud/facebody/model/DetectIPCPedestrianRequest.h
@@ -57,6 +59,8 @@ set(facebody_public_header_model
 	include/alibabacloud/facebody/model/DetectVideoLivingFaceResult.h
 	include/alibabacloud/facebody/model/EnhanceFaceRequest.h
 	include/alibabacloud/facebody/model/EnhanceFaceResult.h
+	include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrRequest.h
+	include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrResult.h
 	include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeRequest.h
 	include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttributeResult.h
 	include/alibabacloud/facebody/model/FaceBeautyRequest.h
@@ -116,6 +120,8 @@ set(facebody_src
 	src/model/DetectBodyCountResult.cc
 	src/model/DetectCelebrityRequest.cc
 	src/model/DetectCelebrityResult.cc
+	src/model/DetectChefCapRequest.cc
+	src/model/DetectChefCapResult.cc
 	src/model/DetectFaceRequest.cc
 	src/model/DetectFaceResult.cc
 	src/model/DetectIPCPedestrianRequest.cc
@@ -130,6 +136,8 @@ set(facebody_src
 	src/model/DetectVideoLivingFaceResult.cc
 	src/model/EnhanceFaceRequest.cc
 	src/model/EnhanceFaceResult.cc
+	src/model/ExtractPedestrianFeatureAttrRequest.cc
+	src/model/ExtractPedestrianFeatureAttrResult.cc
 	src/model/ExtractPedestrianFeatureAttributeRequest.cc
 	src/model/ExtractPedestrianFeatureAttributeResult.cc
 	src/model/FaceBeautyRequest.cc

facebody/include/alibabacloud/facebody/FacebodyClient.h

@@ -44,6 +44,8 @@
 #include "model/DetectBodyCountResult.h"
 #include "model/DetectCelebrityRequest.h"
 #include "model/DetectCelebrityResult.h"
+#include "model/DetectChefCapRequest.h"
+#include "model/DetectChefCapResult.h"
 #include "model/DetectFaceRequest.h"
 #include "model/DetectFaceResult.h"
 #include "model/DetectIPCPedestrianRequest.h"
@@ -58,6 +60,8 @@
 #include "model/DetectVideoLivingFaceResult.h"
 #include "model/EnhanceFaceRequest.h"
 #include "model/EnhanceFaceResult.h"
+#include "model/ExtractPedestrianFeatureAttrRequest.h"
+#include "model/ExtractPedestrianFeatureAttrResult.h"
 #include "model/ExtractPedestrianFeatureAttributeRequest.h"
 #include "model/ExtractPedestrianFeatureAttributeResult.h"
 #include "model/FaceBeautyRequest.h"
@@ -134,6 +138,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DetectCelebrityResult> DetectCelebrityOutcome;
 			typedef std::future<DetectCelebrityOutcome> DetectCelebrityOutcomeCallable;
 			typedef std::function<void(const FacebodyClient*, const Model::DetectCelebrityRequest&, const DetectCelebrityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectCelebrityAsyncHandler;
+			typedef Outcome<Error, Model::DetectChefCapResult> DetectChefCapOutcome;
+			typedef std::future<DetectChefCapOutcome> DetectChefCapOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::DetectChefCapRequest&, const DetectChefCapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectChefCapAsyncHandler;
 			typedef Outcome<Error, Model::DetectFaceResult> DetectFaceOutcome;
 			typedef std::future<DetectFaceOutcome> DetectFaceOutcomeCallable;
 			typedef std::function<void(const FacebodyClient*, const Model::DetectFaceRequest&, const DetectFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectFaceAsyncHandler;
@@ -155,6 +162,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::EnhanceFaceResult> EnhanceFaceOutcome;
 			typedef std::future<EnhanceFaceOutcome> EnhanceFaceOutcomeCallable;
 			typedef std::function<void(const FacebodyClient*, const Model::EnhanceFaceRequest&, const EnhanceFaceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnhanceFaceAsyncHandler;
+			typedef Outcome<Error, Model::ExtractPedestrianFeatureAttrResult> ExtractPedestrianFeatureAttrOutcome;
+			typedef std::future<ExtractPedestrianFeatureAttrOutcome> ExtractPedestrianFeatureAttrOutcomeCallable;
+			typedef std::function<void(const FacebodyClient*, const Model::ExtractPedestrianFeatureAttrRequest&, const ExtractPedestrianFeatureAttrOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractPedestrianFeatureAttrAsyncHandler;
 			typedef Outcome<Error, Model::ExtractPedestrianFeatureAttributeResult> ExtractPedestrianFeatureAttributeOutcome;
 			typedef std::future<ExtractPedestrianFeatureAttributeOutcome> ExtractPedestrianFeatureAttributeOutcomeCallable;
 			typedef std::function<void(const FacebodyClient*, const Model::ExtractPedestrianFeatureAttributeRequest&, const ExtractPedestrianFeatureAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractPedestrianFeatureAttributeAsyncHandler;
@@ -244,6 +254,9 @@ namespace AlibabaCloud
 			DetectCelebrityOutcome detectCelebrity(const Model::DetectCelebrityRequest &request)const;
 			void detectCelebrityAsync(const Model::DetectCelebrityRequest& request, const DetectCelebrityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectCelebrityOutcomeCallable detectCelebrityCallable(const Model::DetectCelebrityRequest& request) const;
+			DetectChefCapOutcome detectChefCap(const Model::DetectChefCapRequest &request)const;
+			void detectChefCapAsync(const Model::DetectChefCapRequest& request, const DetectChefCapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectChefCapOutcomeCallable detectChefCapCallable(const Model::DetectChefCapRequest& request) const;
 			DetectFaceOutcome detectFace(const Model::DetectFaceRequest &request)const;
 			void detectFaceAsync(const Model::DetectFaceRequest& request, const DetectFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectFaceOutcomeCallable detectFaceCallable(const Model::DetectFaceRequest& request) const;
@@ -265,6 +278,9 @@ namespace AlibabaCloud
 			EnhanceFaceOutcome enhanceFace(const Model::EnhanceFaceRequest &request)const;
 			void enhanceFaceAsync(const Model::EnhanceFaceRequest& request, const EnhanceFaceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EnhanceFaceOutcomeCallable enhanceFaceCallable(const Model::EnhanceFaceRequest& request) const;
+			ExtractPedestrianFeatureAttrOutcome extractPedestrianFeatureAttr(const Model::ExtractPedestrianFeatureAttrRequest &request)const;
+			void extractPedestrianFeatureAttrAsync(const Model::ExtractPedestrianFeatureAttrRequest& request, const ExtractPedestrianFeatureAttrAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ExtractPedestrianFeatureAttrOutcomeCallable extractPedestrianFeatureAttrCallable(const Model::ExtractPedestrianFeatureAttrRequest& request) const;
 			ExtractPedestrianFeatureAttributeOutcome extractPedestrianFeatureAttribute(const Model::ExtractPedestrianFeatureAttributeRequest &request)const;
 			void extractPedestrianFeatureAttributeAsync(const Model::ExtractPedestrianFeatureAttributeRequest& request, const ExtractPedestrianFeatureAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExtractPedestrianFeatureAttributeOutcomeCallable extractPedestrianFeatureAttributeCallable(const Model::ExtractPedestrianFeatureAttributeRequest& request) const;

facebody/include/alibabacloud/facebody/model/DetectChefCapRequest.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_FACEBODY_MODEL_DETECTCHEFCAPREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_DETECTCHEFCAPREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT DetectChefCapRequest : public RpcServiceRequest
+			{
+
+			public:
+				DetectChefCapRequest();
+				~DetectChefCapRequest();
+
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_DETECTCHEFCAPREQUEST_H_

facebody/include/alibabacloud/facebody/model/DetectChefCapResult.h

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

facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRREQUEST_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT ExtractPedestrianFeatureAttrRequest : public RpcServiceRequest
+			{
+
+			public:
+				ExtractPedestrianFeatureAttrRequest();
+				~ExtractPedestrianFeatureAttrRequest();
+
+				std::string getMode()const;
+				void setMode(const std::string& mode);
+				std::string getImageURL()const;
+				void setImageURL(const std::string& imageURL);
+
+            private:
+				std::string mode_;
+				std::string imageURL_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRREQUEST_H_

facebody/include/alibabacloud/facebody/model/ExtractPedestrianFeatureAttrResult.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRRESULT_H_
+#define ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/facebody/FacebodyExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Facebody
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_FACEBODY_EXPORT ExtractPedestrianFeatureAttrResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					std::string hair;
+					std::string upperType;
+					float upperTypeScore;
+					float qualityScore;
+					std::string lowerColor;
+					std::string gender;
+					std::string feature;
+					float upperColorScore;
+					float lowerColorScore;
+					float genderScore;
+					std::string objType;
+					float lowerTypeScore;
+					float hairScore;
+					std::string upperColor;
+					std::string lowerType;
+					float ageScore;
+					float objTypeScore;
+					std::string age;
+				};
+
+
+				ExtractPedestrianFeatureAttrResult();
+				explicit ExtractPedestrianFeatureAttrResult(const std::string &payload);
+				~ExtractPedestrianFeatureAttrResult();
+				Data getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				Data data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_FACEBODY_MODEL_EXTRACTPEDESTRIANFEATUREATTRRESULT_H_

facebody/src/FacebodyClient.cc

@@ -447,6 +447,42 @@ FacebodyClient::DetectCelebrityOutcomeCallable FacebodyClient::detectCelebrityCa
 	return task->get_future();
 }
 
+FacebodyClient::DetectChefCapOutcome FacebodyClient::detectChefCap(const DetectChefCapRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DetectChefCapOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DetectChefCapOutcome(DetectChefCapResult(outcome.result()));
+	else
+		return DetectChefCapOutcome(outcome.error());
+}
+
+void FacebodyClient::detectChefCapAsync(const DetectChefCapRequest& request, const DetectChefCapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, detectChefCap(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::DetectChefCapOutcomeCallable FacebodyClient::detectChefCapCallable(const DetectChefCapRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DetectChefCapOutcome()>>(
+			[this, request]()
+			{
+			return this->detectChefCap(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 FacebodyClient::DetectFaceOutcome FacebodyClient::detectFace(const DetectFaceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -699,6 +735,42 @@ FacebodyClient::EnhanceFaceOutcomeCallable FacebodyClient::enhanceFaceCallable(c
 	return task->get_future();
 }
 
+FacebodyClient::ExtractPedestrianFeatureAttrOutcome FacebodyClient::extractPedestrianFeatureAttr(const ExtractPedestrianFeatureAttrRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ExtractPedestrianFeatureAttrOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ExtractPedestrianFeatureAttrOutcome(ExtractPedestrianFeatureAttrResult(outcome.result()));
+	else
+		return ExtractPedestrianFeatureAttrOutcome(outcome.error());
+}
+
+void FacebodyClient::extractPedestrianFeatureAttrAsync(const ExtractPedestrianFeatureAttrRequest& request, const ExtractPedestrianFeatureAttrAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, extractPedestrianFeatureAttr(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+FacebodyClient::ExtractPedestrianFeatureAttrOutcomeCallable FacebodyClient::extractPedestrianFeatureAttrCallable(const ExtractPedestrianFeatureAttrRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ExtractPedestrianFeatureAttrOutcome()>>(
+			[this, request]()
+			{
+			return this->extractPedestrianFeatureAttr(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 FacebodyClient::ExtractPedestrianFeatureAttributeOutcome FacebodyClient::extractPedestrianFeatureAttribute(const ExtractPedestrianFeatureAttributeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

facebody/src/model/DetectChefCapRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/facebody/model/DetectChefCapRequest.h>
+
+using AlibabaCloud::Facebody::Model::DetectChefCapRequest;
+
+DetectChefCapRequest::DetectChefCapRequest() :
+	RpcServiceRequest("facebody", "2019-12-30", "DetectChefCap")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DetectChefCapRequest::~DetectChefCapRequest()
+{}
+
+std::string DetectChefCapRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void DetectChefCapRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+

facebody/src/model/DetectChefCapResult.cc

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/facebody/model/DetectChefCapResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Facebody;
+using namespace AlibabaCloud::Facebody::Model;
+
+DetectChefCapResult::DetectChefCapResult() :
+	ServiceResult()
+{}
+
+DetectChefCapResult::DetectChefCapResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DetectChefCapResult::~DetectChefCapResult()
+{}
+
+void DetectChefCapResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allElementsNode = dataNode["Elements"]["ElementsItem"];
+	for (auto dataNodeElementsElementsItem : allElementsNode)
+	{
+		Data::ElementsItem elementsItemObject;
+		if(!dataNodeElementsElementsItem["Category"].isNull())
+			elementsItemObject.category = dataNodeElementsElementsItem["Category"].asString();
+		if(!dataNodeElementsElementsItem["Confidence"].isNull())
+			elementsItemObject.confidence = std::stof(dataNodeElementsElementsItem["Confidence"].asString());
+		auto allBox = value["Box"]["Box"];
+		for (auto value : allBox)
+			elementsItemObject.box.push_back(value.asString());
+		data_.elements.push_back(elementsItemObject);
+	}
+
+}
+
+DetectChefCapResult::Data DetectChefCapResult::getData()const
+{
+	return data_;
+}
+

facebody/src/model/ExtractPedestrianFeatureAttrRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/facebody/model/ExtractPedestrianFeatureAttrRequest.h>
+
+using AlibabaCloud::Facebody::Model::ExtractPedestrianFeatureAttrRequest;
+
+ExtractPedestrianFeatureAttrRequest::ExtractPedestrianFeatureAttrRequest() :
+	RpcServiceRequest("facebody", "2019-12-30", "ExtractPedestrianFeatureAttr")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ExtractPedestrianFeatureAttrRequest::~ExtractPedestrianFeatureAttrRequest()
+{}
+
+std::string ExtractPedestrianFeatureAttrRequest::getMode()const
+{
+	return mode_;
+}
+
+void ExtractPedestrianFeatureAttrRequest::setMode(const std::string& mode)
+{
+	mode_ = mode;
+	setBodyParameter("Mode", mode);
+}
+
+std::string ExtractPedestrianFeatureAttrRequest::getImageURL()const
+{
+	return imageURL_;
+}
+
+void ExtractPedestrianFeatureAttrRequest::setImageURL(const std::string& imageURL)
+{
+	imageURL_ = imageURL;
+	setBodyParameter("ImageURL", imageURL);
+}
+

facebody/src/model/ExtractPedestrianFeatureAttrResult.cc

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/facebody/model/ExtractPedestrianFeatureAttrResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Facebody;
+using namespace AlibabaCloud::Facebody::Model;
+
+ExtractPedestrianFeatureAttrResult::ExtractPedestrianFeatureAttrResult() :
+	ServiceResult()
+{}
+
+ExtractPedestrianFeatureAttrResult::ExtractPedestrianFeatureAttrResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ExtractPedestrianFeatureAttrResult::~ExtractPedestrianFeatureAttrResult()
+{}
+
+void ExtractPedestrianFeatureAttrResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["ObjType"].isNull())
+		data_.objType = dataNode["ObjType"].asString();
+	if(!dataNode["ObjTypeScore"].isNull())
+		data_.objTypeScore = std::stof(dataNode["ObjTypeScore"].asString());
+	if(!dataNode["Feature"].isNull())
+		data_.feature = dataNode["Feature"].asString();
+	if(!dataNode["QualityScore"].isNull())
+		data_.qualityScore = std::stof(dataNode["QualityScore"].asString());
+	if(!dataNode["UpperColor"].isNull())
+		data_.upperColor = dataNode["UpperColor"].asString();
+	if(!dataNode["UpperColorScore"].isNull())
+		data_.upperColorScore = std::stof(dataNode["UpperColorScore"].asString());
+	if(!dataNode["UpperType"].isNull())
+		data_.upperType = dataNode["UpperType"].asString();
+	if(!dataNode["UpperTypeScore"].isNull())
+		data_.upperTypeScore = std::stof(dataNode["UpperTypeScore"].asString());
+	if(!dataNode["LowerColor"].isNull())
+		data_.lowerColor = dataNode["LowerColor"].asString();
+	if(!dataNode["LowerColorScore"].isNull())
+		data_.lowerColorScore = std::stof(dataNode["LowerColorScore"].asString());
+	if(!dataNode["LowerType"].isNull())
+		data_.lowerType = dataNode["LowerType"].asString();
+	if(!dataNode["LowerTypeScore"].isNull())
+		data_.lowerTypeScore = std::stof(dataNode["LowerTypeScore"].asString());
+	if(!dataNode["Gender"].isNull())
+		data_.gender = dataNode["Gender"].asString();
+	if(!dataNode["GenderScore"].isNull())
+		data_.genderScore = std::stof(dataNode["GenderScore"].asString());
+	if(!dataNode["Hair"].isNull())
+		data_.hair = dataNode["Hair"].asString();
+	if(!dataNode["HairScore"].isNull())
+		data_.hairScore = std::stof(dataNode["HairScore"].asString());
+	if(!dataNode["Age"].isNull())
+		data_.age = dataNode["Age"].asString();
+	if(!dataNode["AgeScore"].isNull())
+		data_.ageScore = std::stof(dataNode["AgeScore"].asString());
+
+}
+
+ExtractPedestrianFeatureAttrResult::Data ExtractPedestrianFeatureAttrResult::getData()const
+{
+	return data_;
+}
+

imageprocess/CMakeLists.txt

@@ -21,8 +21,16 @@ set(imageprocess_public_header
 	include/alibabacloud/imageprocess/ImageprocessExport.h )
 
 set(imageprocess_public_header_model 
+	include/alibabacloud/imageprocess/model/CalcCACSRequest.h
+	include/alibabacloud/imageprocess/model/CalcCACSResult.h
+	include/alibabacloud/imageprocess/model/ClassifyFNFRequest.h
+	include/alibabacloud/imageprocess/model/ClassifyFNFResult.h
 	include/alibabacloud/imageprocess/model/DetectCovid19CadRequest.h
 	include/alibabacloud/imageprocess/model/DetectCovid19CadResult.h
+	include/alibabacloud/imageprocess/model/DetectHipKeypointXRayRequest.h
+	include/alibabacloud/imageprocess/model/DetectHipKeypointXRayResult.h
+	include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayRequest.h
+	include/alibabacloud/imageprocess/model/DetectKneeKeypointXRayResult.h
 	include/alibabacloud/imageprocess/model/DetectKneeXRayRequest.h
 	include/alibabacloud/imageprocess/model/DetectKneeXRayResult.h
 	include/alibabacloud/imageprocess/model/DetectLungNoduleRequest.h
@@ -31,13 +39,23 @@ set(imageprocess_public_header_model
 	include/alibabacloud/imageprocess/model/DetectSpineMRIResult.h
 	include/alibabacloud/imageprocess/model/GetAsyncJobResultRequest.h
 	include/alibabacloud/imageprocess/model/GetAsyncJobResultResult.h
+	include/alibabacloud/imageprocess/model/RunCTRegistrationRequest.h
+	include/alibabacloud/imageprocess/model/RunCTRegistrationResult.h
 	include/alibabacloud/imageprocess/model/TranslateMedRequest.h
 	include/alibabacloud/imageprocess/model/TranslateMedResult.h )
 
 set(imageprocess_src 
 	src/ImageprocessClient.cc
+	src/model/CalcCACSRequest.cc
+	src/model/CalcCACSResult.cc
+	src/model/ClassifyFNFRequest.cc
+	src/model/ClassifyFNFResult.cc
 	src/model/DetectCovid19CadRequest.cc
 	src/model/DetectCovid19CadResult.cc
+	src/model/DetectHipKeypointXRayRequest.cc
+	src/model/DetectHipKeypointXRayResult.cc
+	src/model/DetectKneeKeypointXRayRequest.cc
+	src/model/DetectKneeKeypointXRayResult.cc
 	src/model/DetectKneeXRayRequest.cc
 	src/model/DetectKneeXRayResult.cc
 	src/model/DetectLungNoduleRequest.cc
@@ -46,6 +64,8 @@ set(imageprocess_src
 	src/model/DetectSpineMRIResult.cc
 	src/model/GetAsyncJobResultRequest.cc
 	src/model/GetAsyncJobResultResult.cc
+	src/model/RunCTRegistrationRequest.cc
+	src/model/RunCTRegistrationResult.cc
 	src/model/TranslateMedRequest.cc
 	src/model/TranslateMedResult.cc )
 

imageprocess/include/alibabacloud/imageprocess/ImageprocessClient.h

@@ -22,8 +22,16 @@
 #include <alibabacloud/core/EndpointProvider.h>
 #include <alibabacloud/core/RpcServiceClient.h>
 #include "ImageprocessExport.h"
+#include "model/CalcCACSRequest.h"
+#include "model/CalcCACSResult.h"
+#include "model/ClassifyFNFRequest.h"
+#include "model/ClassifyFNFResult.h"
 #include "model/DetectCovid19CadRequest.h"
 #include "model/DetectCovid19CadResult.h"
+#include "model/DetectHipKeypointXRayRequest.h"
+#include "model/DetectHipKeypointXRayResult.h"
+#include "model/DetectKneeKeypointXRayRequest.h"
+#include "model/DetectKneeKeypointXRayResult.h"
 #include "model/DetectKneeXRayRequest.h"
 #include "model/DetectKneeXRayResult.h"
 #include "model/DetectLungNoduleRequest.h"
@@ -32,6 +40,8 @@
 #include "model/DetectSpineMRIResult.h"
 #include "model/GetAsyncJobResultRequest.h"
 #include "model/GetAsyncJobResultResult.h"
+#include "model/RunCTRegistrationRequest.h"
+#include "model/RunCTRegistrationResult.h"
 #include "model/TranslateMedRequest.h"
 #include "model/TranslateMedResult.h"
 
@@ -43,9 +53,21 @@ namespace AlibabaCloud
 		class ALIBABACLOUD_IMAGEPROCESS_EXPORT ImageprocessClient : public RpcServiceClient
 		{
 		public:
+			typedef Outcome<Error, Model::CalcCACSResult> CalcCACSOutcome;
+			typedef std::future<CalcCACSOutcome> CalcCACSOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::CalcCACSRequest&, const CalcCACSOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CalcCACSAsyncHandler;
+			typedef Outcome<Error, Model::ClassifyFNFResult> ClassifyFNFOutcome;
+			typedef std::future<ClassifyFNFOutcome> ClassifyFNFOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::ClassifyFNFRequest&, const ClassifyFNFOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ClassifyFNFAsyncHandler;
 			typedef Outcome<Error, Model::DetectCovid19CadResult> DetectCovid19CadOutcome;
 			typedef std::future<DetectCovid19CadOutcome> DetectCovid19CadOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::DetectCovid19CadRequest&, const DetectCovid19CadOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectCovid19CadAsyncHandler;
+			typedef Outcome<Error, Model::DetectHipKeypointXRayResult> DetectHipKeypointXRayOutcome;
+			typedef std::future<DetectHipKeypointXRayOutcome> DetectHipKeypointXRayOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::DetectHipKeypointXRayRequest&, const DetectHipKeypointXRayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectHipKeypointXRayAsyncHandler;
+			typedef Outcome<Error, Model::DetectKneeKeypointXRayResult> DetectKneeKeypointXRayOutcome;
+			typedef std::future<DetectKneeKeypointXRayOutcome> DetectKneeKeypointXRayOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::DetectKneeKeypointXRayRequest&, const DetectKneeKeypointXRayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectKneeKeypointXRayAsyncHandler;
 			typedef Outcome<Error, Model::DetectKneeXRayResult> DetectKneeXRayOutcome;
 			typedef std::future<DetectKneeXRayOutcome> DetectKneeXRayOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::DetectKneeXRayRequest&, const DetectKneeXRayOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DetectKneeXRayAsyncHandler;
@@ -58,6 +80,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
 			typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
+			typedef Outcome<Error, Model::RunCTRegistrationResult> RunCTRegistrationOutcome;
+			typedef std::future<RunCTRegistrationOutcome> RunCTRegistrationOutcomeCallable;
+			typedef std::function<void(const ImageprocessClient*, const Model::RunCTRegistrationRequest&, const RunCTRegistrationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RunCTRegistrationAsyncHandler;
 			typedef Outcome<Error, Model::TranslateMedResult> TranslateMedOutcome;
 			typedef std::future<TranslateMedOutcome> TranslateMedOutcomeCallable;
 			typedef std::function<void(const ImageprocessClient*, const Model::TranslateMedRequest&, const TranslateMedOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TranslateMedAsyncHandler;
@@ -66,9 +91,21 @@ namespace AlibabaCloud
 			ImageprocessClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
 			ImageprocessClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
 			~ImageprocessClient();
+			CalcCACSOutcome calcCACS(const Model::CalcCACSRequest &request)const;
+			void calcCACSAsync(const Model::CalcCACSRequest& request, const CalcCACSAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CalcCACSOutcomeCallable calcCACSCallable(const Model::CalcCACSRequest& request) const;
+			ClassifyFNFOutcome classifyFNF(const Model::ClassifyFNFRequest &request)const;
+			void classifyFNFAsync(const Model::ClassifyFNFRequest& request, const ClassifyFNFAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ClassifyFNFOutcomeCallable classifyFNFCallable(const Model::ClassifyFNFRequest& request) const;
 			DetectCovid19CadOutcome detectCovid19Cad(const Model::DetectCovid19CadRequest &request)const;
 			void detectCovid19CadAsync(const Model::DetectCovid19CadRequest& request, const DetectCovid19CadAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectCovid19CadOutcomeCallable detectCovid19CadCallable(const Model::DetectCovid19CadRequest& request) const;
+			DetectHipKeypointXRayOutcome detectHipKeypointXRay(const Model::DetectHipKeypointXRayRequest &request)const;
+			void detectHipKeypointXRayAsync(const Model::DetectHipKeypointXRayRequest& request, const DetectHipKeypointXRayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectHipKeypointXRayOutcomeCallable detectHipKeypointXRayCallable(const Model::DetectHipKeypointXRayRequest& request) const;
+			DetectKneeKeypointXRayOutcome detectKneeKeypointXRay(const Model::DetectKneeKeypointXRayRequest &request)const;
+			void detectKneeKeypointXRayAsync(const Model::DetectKneeKeypointXRayRequest& request, const DetectKneeKeypointXRayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DetectKneeKeypointXRayOutcomeCallable detectKneeKeypointXRayCallable(const Model::DetectKneeKeypointXRayRequest& request) const;
 			DetectKneeXRayOutcome detectKneeXRay(const Model::DetectKneeXRayRequest &request)const;
 			void detectKneeXRayAsync(const Model::DetectKneeXRayRequest& request, const DetectKneeXRayAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DetectKneeXRayOutcomeCallable detectKneeXRayCallable(const Model::DetectKneeXRayRequest& request) const;
@@ -81,6 +118,9 @@ namespace AlibabaCloud
 			GetAsyncJobResultOutcome getAsyncJobResult(const Model::GetAsyncJobResultRequest &request)const;
 			void getAsyncJobResultAsync(const Model::GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAsyncJobResultOutcomeCallable getAsyncJobResultCallable(const Model::GetAsyncJobResultRequest& request) const;
+			RunCTRegistrationOutcome runCTRegistration(const Model::RunCTRegistrationRequest &request)const;
+			void runCTRegistrationAsync(const Model::RunCTRegistrationRequest& request, const RunCTRegistrationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RunCTRegistrationOutcomeCallable runCTRegistrationCallable(const Model::RunCTRegistrationRequest& request) const;
 			TranslateMedOutcome translateMed(const Model::TranslateMedRequest &request)const;
 			void translateMedAsync(const Model::TranslateMedRequest& request, const TranslateMedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			TranslateMedOutcomeCallable translateMedCallable(const Model::TranslateMedRequest& request) const;

imageprocess/include/alibabacloud/imageprocess/model/CalcCACSRequest.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_
+#define ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/imageprocess/ImageprocessExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Imageprocess
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_IMAGEPROCESS_EXPORT CalcCACSRequest : public RpcServiceRequest
+			{
+			public:
+				struct URLList
+				{
+					std::string uRL;
+				};
+
+			public:
+				CalcCACSRequest();
+				~CalcCACSRequest();
+
+				std::string getDataSourceType()const;
+				void setDataSourceType(const std::string& dataSourceType);
+				std::string getDataFormat()const;
+				void setDataFormat(const std::string& dataFormat);
+				std::vector<URLList> getURLList()const;
+				void setURLList(const std::vector<URLList>& uRLList);
+				std::string getOrgId()const;
+				void setOrgId(const std::string& orgId);
+				bool getAsync()const;
+				void setAsync(bool async);
+				std::string getOrgName()const;
+				void setOrgName(const std::string& orgName);
+
+            private:
+				std::string dataSourceType_;
+				std::string dataFormat_;
+				std::vector<URLList> uRLList_;
+				std::string orgId_;
+				bool async_;
+				std::string orgName_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_IMAGEPROCESS_MODEL_CALCCACSREQUEST_H_

imageprocess/include/alibabacloud/imageprocess/model/CalcCACSResult.h

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