regenerate code

scdn/src/ScdnClient.cc

@@ -267,6 +267,150 @@ ScdnClient::DeleteScdnDomainOutcomeCallable ScdnClient::deleteScdnDomainCallable
 	return task->get_future();
 }
 
+ScdnClient::DeleteScdnSpecificConfigOutcome ScdnClient::deleteScdnSpecificConfig(const DeleteScdnSpecificConfigRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteScdnSpecificConfigOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteScdnSpecificConfigOutcome(DeleteScdnSpecificConfigResult(outcome.result()));
+	else
+		return DeleteScdnSpecificConfigOutcome(outcome.error());
+}
+
+void ScdnClient::deleteScdnSpecificConfigAsync(const DeleteScdnSpecificConfigRequest& request, const DeleteScdnSpecificConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteScdnSpecificConfig(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DeleteScdnSpecificConfigOutcomeCallable ScdnClient::deleteScdnSpecificConfigCallable(const DeleteScdnSpecificConfigRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteScdnSpecificConfigOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteScdnSpecificConfig(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnCcQpsInfoOutcome ScdnClient::describeScdnCcQpsInfo(const DescribeScdnCcQpsInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnCcQpsInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnCcQpsInfoOutcome(DescribeScdnCcQpsInfoResult(outcome.result()));
+	else
+		return DescribeScdnCcQpsInfoOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnCcQpsInfoAsync(const DescribeScdnCcQpsInfoRequest& request, const DescribeScdnCcQpsInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnCcQpsInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnCcQpsInfoOutcomeCallable ScdnClient::describeScdnCcQpsInfoCallable(const DescribeScdnCcQpsInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnCcQpsInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnCcQpsInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnCcTopIpOutcome ScdnClient::describeScdnCcTopIp(const DescribeScdnCcTopIpRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnCcTopIpOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnCcTopIpOutcome(DescribeScdnCcTopIpResult(outcome.result()));
+	else
+		return DescribeScdnCcTopIpOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnCcTopIpAsync(const DescribeScdnCcTopIpRequest& request, const DescribeScdnCcTopIpAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnCcTopIp(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnCcTopIpOutcomeCallable ScdnClient::describeScdnCcTopIpCallable(const DescribeScdnCcTopIpRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnCcTopIpOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnCcTopIp(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnCcTopUrlOutcome ScdnClient::describeScdnCcTopUrl(const DescribeScdnCcTopUrlRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnCcTopUrlOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnCcTopUrlOutcome(DescribeScdnCcTopUrlResult(outcome.result()));
+	else
+		return DescribeScdnCcTopUrlOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnCcTopUrlAsync(const DescribeScdnCcTopUrlRequest& request, const DescribeScdnCcTopUrlAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnCcTopUrl(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnCcTopUrlOutcomeCallable ScdnClient::describeScdnCcTopUrlCallable(const DescribeScdnCcTopUrlRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnCcTopUrlOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnCcTopUrl(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::DescribeScdnCertificateDetailOutcome ScdnClient::describeScdnCertificateDetail(const DescribeScdnCertificateDetailRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +483,78 @@ ScdnClient::DescribeScdnCertificateListOutcomeCallable ScdnClient::describeScdnC
 	return task->get_future();
 }
 
+ScdnClient::DescribeScdnDdosInfoOutcome ScdnClient::describeScdnDdosInfo(const DescribeScdnDdosInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDdosInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDdosInfoOutcome(DescribeScdnDdosInfoResult(outcome.result()));
+	else
+		return DescribeScdnDdosInfoOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDdosInfoAsync(const DescribeScdnDdosInfoRequest& request, const DescribeScdnDdosInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDdosInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDdosInfoOutcomeCallable ScdnClient::describeScdnDdosInfoCallable(const DescribeScdnDdosInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDdosInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDdosInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDdosTrafficInfoOutcome ScdnClient::describeScdnDdosTrafficInfo(const DescribeScdnDdosTrafficInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDdosTrafficInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDdosTrafficInfoOutcome(DescribeScdnDdosTrafficInfoResult(outcome.result()));
+	else
+		return DescribeScdnDdosTrafficInfoOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDdosTrafficInfoAsync(const DescribeScdnDdosTrafficInfoRequest& request, const DescribeScdnDdosTrafficInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDdosTrafficInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDdosTrafficInfoOutcomeCallable ScdnClient::describeScdnDdosTrafficInfoCallable(const DescribeScdnDdosTrafficInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDdosTrafficInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDdosTrafficInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::DescribeScdnDomainBpsDataOutcome ScdnClient::describeScdnDomainBpsData(const DescribeScdnDomainBpsDataRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1635,6 +1851,150 @@ ScdnClient::SetDomainServerCertificateOutcomeCallable ScdnClient::setDomainServe
 	return task->get_future();
 }
 
+ScdnClient::SetScdnBotInfoOutcome ScdnClient::setScdnBotInfo(const SetScdnBotInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetScdnBotInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetScdnBotInfoOutcome(SetScdnBotInfoResult(outcome.result()));
+	else
+		return SetScdnBotInfoOutcome(outcome.error());
+}
+
+void ScdnClient::setScdnBotInfoAsync(const SetScdnBotInfoRequest& request, const SetScdnBotInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setScdnBotInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::SetScdnBotInfoOutcomeCallable ScdnClient::setScdnBotInfoCallable(const SetScdnBotInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetScdnBotInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->setScdnBotInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::SetScdnCcInfoOutcome ScdnClient::setScdnCcInfo(const SetScdnCcInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetScdnCcInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetScdnCcInfoOutcome(SetScdnCcInfoResult(outcome.result()));
+	else
+		return SetScdnCcInfoOutcome(outcome.error());
+}
+
+void ScdnClient::setScdnCcInfoAsync(const SetScdnCcInfoRequest& request, const SetScdnCcInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setScdnCcInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::SetScdnCcInfoOutcomeCallable ScdnClient::setScdnCcInfoCallable(const SetScdnCcInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetScdnCcInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->setScdnCcInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::SetScdnDdosInfoOutcome ScdnClient::setScdnDdosInfo(const SetScdnDdosInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetScdnDdosInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetScdnDdosInfoOutcome(SetScdnDdosInfoResult(outcome.result()));
+	else
+		return SetScdnDdosInfoOutcome(outcome.error());
+}
+
+void ScdnClient::setScdnDdosInfoAsync(const SetScdnDdosInfoRequest& request, const SetScdnDdosInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setScdnDdosInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::SetScdnDdosInfoOutcomeCallable ScdnClient::setScdnDdosInfoCallable(const SetScdnDdosInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetScdnDdosInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->setScdnDdosInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::SetScdnDomainBizInfoOutcome ScdnClient::setScdnDomainBizInfo(const SetScdnDomainBizInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetScdnDomainBizInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetScdnDomainBizInfoOutcome(SetScdnDomainBizInfoResult(outcome.result()));
+	else
+		return SetScdnDomainBizInfoOutcome(outcome.error());
+}
+
+void ScdnClient::setScdnDomainBizInfoAsync(const SetScdnDomainBizInfoRequest& request, const SetScdnDomainBizInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setScdnDomainBizInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::SetScdnDomainBizInfoOutcomeCallable ScdnClient::setScdnDomainBizInfoCallable(const SetScdnDomainBizInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetScdnDomainBizInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->setScdnDomainBizInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 ScdnClient::SetScdnDomainCertificateOutcome ScdnClient::setScdnDomainCertificate(const SetScdnDomainCertificateRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

scdn/src/model/AddScdnDomainRequest.cc

@@ -35,7 +35,7 @@ std::string AddScdnDomainRequest::getSources()const
 void AddScdnDomainRequest::setSources(const std::string& sources)
 {
 	sources_ = sources;
-	setCoreParameter("Sources", sources);
+	setParameter("Sources", sources);
 }
 
 std::string AddScdnDomainRequest::getResourceGroupId()const
@@ -46,7 +46,7 @@ std::string AddScdnDomainRequest::getResourceGroupId()const
 void AddScdnDomainRequest::setResourceGroupId(const std::string& resourceGroupId)
 {
 	resourceGroupId_ = resourceGroupId;
-	setCoreParameter("ResourceGroupId", resourceGroupId);
+	setParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string AddScdnDomainRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string AddScdnDomainRequest::getSecurityToken()const
 void AddScdnDomainRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string AddScdnDomainRequest::getScope()const
@@ -68,7 +68,7 @@ std::string AddScdnDomainRequest::getScope()const
 void AddScdnDomainRequest::setScope(const std::string& scope)
 {
 	scope_ = scope;
-	setCoreParameter("Scope", scope);
+	setParameter("Scope", scope);
 }
 
 std::string AddScdnDomainRequest::getOwnerAccount()const
@@ -79,7 +79,7 @@ std::string AddScdnDomainRequest::getOwnerAccount()const
 void AddScdnDomainRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::string AddScdnDomainRequest::getDomainName()const
@@ -90,7 +90,7 @@ std::string AddScdnDomainRequest::getDomainName()const
 void AddScdnDomainRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long AddScdnDomainRequest::getOwnerId()const
@@ -101,7 +101,7 @@ long AddScdnDomainRequest::getOwnerId()const
 void AddScdnDomainRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string AddScdnDomainRequest::getCheckUrl()const
@@ -112,6 +112,6 @@ std::string AddScdnDomainRequest::getCheckUrl()const
 void AddScdnDomainRequest::setCheckUrl(const std::string& checkUrl)
 {
 	checkUrl_ = checkUrl;
-	setCoreParameter("CheckUrl", checkUrl);
+	setParameter("CheckUrl", checkUrl);
 }
 

scdn/src/model/BatchDeleteScdnDomainConfigsRequest.cc

@@ -35,7 +35,7 @@ std::string BatchDeleteScdnDomainConfigsRequest::getFunctionNames()const
 void BatchDeleteScdnDomainConfigsRequest::setFunctionNames(const std::string& functionNames)
 {
 	functionNames_ = functionNames;
-	setCoreParameter("FunctionNames", functionNames);
+	setParameter("FunctionNames", functionNames);
 }
 
 std::string BatchDeleteScdnDomainConfigsRequest::getDomainNames()const
@@ -46,7 +46,7 @@ std::string BatchDeleteScdnDomainConfigsRequest::getDomainNames()const
 void BatchDeleteScdnDomainConfigsRequest::setDomainNames(const std::string& domainNames)
 {
 	domainNames_ = domainNames;
-	setCoreParameter("DomainNames", domainNames);
+	setParameter("DomainNames", domainNames);
 }
 
 std::string BatchDeleteScdnDomainConfigsRequest::getOwnerAccount()const
@@ -57,7 +57,7 @@ std::string BatchDeleteScdnDomainConfigsRequest::getOwnerAccount()const
 void BatchDeleteScdnDomainConfigsRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long BatchDeleteScdnDomainConfigsRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long BatchDeleteScdnDomainConfigsRequest::getOwnerId()const
 void BatchDeleteScdnDomainConfigsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string BatchDeleteScdnDomainConfigsRequest::getSecurityToken()const
@@ -79,6 +79,6 @@ std::string BatchDeleteScdnDomainConfigsRequest::getSecurityToken()const
 void BatchDeleteScdnDomainConfigsRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/BatchSetScdnDomainConfigsRequest.cc

@@ -35,7 +35,7 @@ std::string BatchSetScdnDomainConfigsRequest::getFunctions()const
 void BatchSetScdnDomainConfigsRequest::setFunctions(const std::string& functions)
 {
 	functions_ = functions;
-	setCoreParameter("Functions", functions);
+	setParameter("Functions", functions);
 }
 
 std::string BatchSetScdnDomainConfigsRequest::getDomainNames()const
@@ -46,7 +46,7 @@ std::string BatchSetScdnDomainConfigsRequest::getDomainNames()const
 void BatchSetScdnDomainConfigsRequest::setDomainNames(const std::string& domainNames)
 {
 	domainNames_ = domainNames;
-	setCoreParameter("DomainNames", domainNames);
+	setParameter("DomainNames", domainNames);
 }
 
 std::string BatchSetScdnDomainConfigsRequest::getOwnerAccount()const
@@ -57,7 +57,7 @@ std::string BatchSetScdnDomainConfigsRequest::getOwnerAccount()const
 void BatchSetScdnDomainConfigsRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 long BatchSetScdnDomainConfigsRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long BatchSetScdnDomainConfigsRequest::getOwnerId()const
 void BatchSetScdnDomainConfigsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string BatchSetScdnDomainConfigsRequest::getSecurityToken()const
@@ -79,6 +79,6 @@ std::string BatchSetScdnDomainConfigsRequest::getSecurityToken()const
 void BatchSetScdnDomainConfigsRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/BatchUpdateScdnDomainRequest.cc

@@ -27,17 +27,6 @@ BatchUpdateScdnDomainRequest::BatchUpdateScdnDomainRequest() :
 BatchUpdateScdnDomainRequest::~BatchUpdateScdnDomainRequest()
 {}
 
-std::string BatchUpdateScdnDomainRequest::getTopLevelDomain()const
-{
-	return topLevelDomain_;
-}
-
-void BatchUpdateScdnDomainRequest::setTopLevelDomain(const std::string& topLevelDomain)
-{
-	topLevelDomain_ = topLevelDomain;
-	setCoreParameter("TopLevelDomain", topLevelDomain);
-}
-
 std::string BatchUpdateScdnDomainRequest::getSources()const
 {
 	return sources_;
@@ -46,29 +35,7 @@ std::string BatchUpdateScdnDomainRequest::getSources()const
 void BatchUpdateScdnDomainRequest::setSources(const std::string& sources)
 {
 	sources_ = sources;
-	setCoreParameter("Sources", sources);
-}
-
-std::string BatchUpdateScdnDomainRequest::getDomainName()const
-{
-	return domainName_;
-}
-
-void BatchUpdateScdnDomainRequest::setDomainName(const std::string& domainName)
-{
-	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
-}
-
-long BatchUpdateScdnDomainRequest::getOwnerId()const
-{
-	return ownerId_;
-}
-
-void BatchUpdateScdnDomainRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("Sources", sources);
 }
 
 std::string BatchUpdateScdnDomainRequest::getResourceGroupId()const
@@ -79,7 +46,7 @@ std::string BatchUpdateScdnDomainRequest::getResourceGroupId()const
 void BatchUpdateScdnDomainRequest::setResourceGroupId(const std::string& resourceGroupId)
 {
 	resourceGroupId_ = resourceGroupId;
-	setCoreParameter("ResourceGroupId", resourceGroupId);
+	setParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string BatchUpdateScdnDomainRequest::getSecurityToken()const
@@ -90,6 +57,39 @@ std::string BatchUpdateScdnDomainRequest::getSecurityToken()const
 void BatchUpdateScdnDomainRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string BatchUpdateScdnDomainRequest::getTopLevelDomain()const
+{
+	return topLevelDomain_;
+}
+
+void BatchUpdateScdnDomainRequest::setTopLevelDomain(const std::string& topLevelDomain)
+{
+	topLevelDomain_ = topLevelDomain;
+	setParameter("TopLevelDomain", topLevelDomain);
+}
+
+std::string BatchUpdateScdnDomainRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void BatchUpdateScdnDomainRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long BatchUpdateScdnDomainRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void BatchUpdateScdnDomainRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/CheckScdnServiceRequest.cc

@@ -35,7 +35,7 @@ long CheckScdnServiceRequest::getOwnerId()const
 void CheckScdnServiceRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string CheckScdnServiceRequest::getSecurityToken()const
@@ -46,6 +46,6 @@ std::string CheckScdnServiceRequest::getSecurityToken()const
 void CheckScdnServiceRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/DeleteScdnDomainRequest.cc

@@ -35,7 +35,7 @@ std::string DeleteScdnDomainRequest::getOwnerAccount()const
 void DeleteScdnDomainRequest::setOwnerAccount(const std::string& ownerAccount)
 {
 	ownerAccount_ = ownerAccount;
-	setCoreParameter("OwnerAccount", ownerAccount);
+	setParameter("OwnerAccount", ownerAccount);
 }
 
 std::string DeleteScdnDomainRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DeleteScdnDomainRequest::getDomainName()const
 void DeleteScdnDomainRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long DeleteScdnDomainRequest::getOwnerId()const
@@ -57,7 +57,7 @@ long DeleteScdnDomainRequest::getOwnerId()const
 void DeleteScdnDomainRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DeleteScdnDomainRequest::getResourceGroupId()const
@@ -68,7 +68,7 @@ std::string DeleteScdnDomainRequest::getResourceGroupId()const
 void DeleteScdnDomainRequest::setResourceGroupId(const std::string& resourceGroupId)
 {
 	resourceGroupId_ = resourceGroupId;
-	setCoreParameter("ResourceGroupId", resourceGroupId);
+	setParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string DeleteScdnDomainRequest::getSecurityToken()const
@@ -79,6 +79,6 @@ std::string DeleteScdnDomainRequest::getSecurityToken()const
 void DeleteScdnDomainRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/DeleteScdnSpecificConfigRequest.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/scdn/model/DeleteScdnSpecificConfigRequest.h>
+
+using AlibabaCloud::Scdn::Model::DeleteScdnSpecificConfigRequest;
+
+DeleteScdnSpecificConfigRequest::DeleteScdnSpecificConfigRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DeleteScdnSpecificConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteScdnSpecificConfigRequest::~DeleteScdnSpecificConfigRequest()
+{}
+
+std::string DeleteScdnSpecificConfigRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DeleteScdnSpecificConfigRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long DeleteScdnSpecificConfigRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DeleteScdnSpecificConfigRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DeleteScdnSpecificConfigRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DeleteScdnSpecificConfigRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DeleteScdnSpecificConfigRequest::getConfigId()const
+{
+	return configId_;
+}
+
+void DeleteScdnSpecificConfigRequest::setConfigId(const std::string& configId)
+{
+	configId_ = configId;
+	setParameter("ConfigId", configId);
+}
+

scdn/src/model/DeleteScdnSpecificConfigResult.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/scdn/model/DeleteScdnSpecificConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DeleteScdnSpecificConfigResult::DeleteScdnSpecificConfigResult() :
+	ServiceResult()
+{}
+
+DeleteScdnSpecificConfigResult::DeleteScdnSpecificConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteScdnSpecificConfigResult::~DeleteScdnSpecificConfigResult()
+{}
+
+void DeleteScdnSpecificConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

scdn/src/model/DescribeScdnCcQpsInfoRequest.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/scdn/model/DescribeScdnCcQpsInfoRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnCcQpsInfoRequest;
+
+DescribeScdnCcQpsInfoRequest::DescribeScdnCcQpsInfoRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnCcQpsInfo")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeScdnCcQpsInfoRequest::~DescribeScdnCcQpsInfoRequest()
+{}
+
+std::string DescribeScdnCcQpsInfoRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnCcQpsInfoRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnCcQpsInfoRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnCcQpsInfoRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnCcQpsInfoRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnCcQpsInfoRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeScdnCcQpsInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnCcQpsInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

scdn/src/model/DescribeScdnCcQpsInfoResult.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/scdn/model/DescribeScdnCcQpsInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnCcQpsInfoResult::DescribeScdnCcQpsInfoResult() :
+	ServiceResult()
+{}
+
+DescribeScdnCcQpsInfoResult::DescribeScdnCcQpsInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnCcQpsInfoResult::~DescribeScdnCcQpsInfoResult()
+{}
+
+void DescribeScdnCcQpsInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTimeScopesNode = value["TimeScopes"]["TimeScope"];
+	for (auto valueTimeScopesTimeScope : allTimeScopesNode)
+	{
+		TimeScope timeScopesObject;
+		if(!valueTimeScopesTimeScope["Interval"].isNull())
+			timeScopesObject.interval = valueTimeScopesTimeScope["Interval"].asString();
+		if(!valueTimeScopesTimeScope["Start"].isNull())
+			timeScopesObject.start = valueTimeScopesTimeScope["Start"].asString();
+		timeScopes_.push_back(timeScopesObject);
+	}
+	auto allTotals = value["Totals"]["Total"];
+	for (const auto &item : allTotals)
+		totals_.push_back(item.asString());
+	auto allAttacks = value["Attacks"]["Attack"];
+	for (const auto &item : allAttacks)
+		attacks_.push_back(item.asString());
+
+}
+
+std::vector<DescribeScdnCcQpsInfoResult::TimeScope> DescribeScdnCcQpsInfoResult::getTimeScopes()const
+{
+	return timeScopes_;
+}
+
+std::vector<std::string> DescribeScdnCcQpsInfoResult::getTotals()const
+{
+	return totals_;
+}
+
+std::vector<std::string> DescribeScdnCcQpsInfoResult::getAttacks()const
+{
+	return attacks_;
+}
+

scdn/src/model/DescribeScdnCcTopIpRequest.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/scdn/model/DescribeScdnCcTopIpRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnCcTopIpRequest;
+
+DescribeScdnCcTopIpRequest::DescribeScdnCcTopIpRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnCcTopIp")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeScdnCcTopIpRequest::~DescribeScdnCcTopIpRequest()
+{}
+
+std::string DescribeScdnCcTopIpRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnCcTopIpRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnCcTopIpRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeScdnCcTopIpRequest::setPageNumber(const std::string& pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", pageNumber);
+}
+
+std::string DescribeScdnCcTopIpRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeScdnCcTopIpRequest::setPageSize(const std::string& pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", pageSize);
+}
+
+std::string DescribeScdnCcTopIpRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnCcTopIpRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnCcTopIpRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnCcTopIpRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeScdnCcTopIpRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnCcTopIpRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

scdn/src/model/DescribeScdnCcTopIpResult.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/scdn/model/DescribeScdnCcTopIpResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnCcTopIpResult::DescribeScdnCcTopIpResult() :
+	ServiceResult()
+{}
+
+DescribeScdnCcTopIpResult::DescribeScdnCcTopIpResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnCcTopIpResult::~DescribeScdnCcTopIpResult()
+{}
+
+void DescribeScdnCcTopIpResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAttackIpDataListNode = value["AttackIpDataList"]["AttackIpDatas"];
+	for (auto valueAttackIpDataListAttackIpDatas : allAttackIpDataListNode)
+	{
+		AttackIpDatas attackIpDataListObject;
+		if(!valueAttackIpDataListAttackIpDatas["Ip"].isNull())
+			attackIpDataListObject.ip = valueAttackIpDataListAttackIpDatas["Ip"].asString();
+		if(!valueAttackIpDataListAttackIpDatas["AttackCount"].isNull())
+			attackIpDataListObject.attackCount = valueAttackIpDataListAttackIpDatas["AttackCount"].asString();
+		attackIpDataList_.push_back(attackIpDataListObject);
+	}
+	if(!value["Total"].isNull())
+		total_ = value["Total"].asString();
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+
+}
+
+std::string DescribeScdnCcTopIpResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeScdnCcTopIpResult::getTotal()const
+{
+	return total_;
+}
+
+std::vector<DescribeScdnCcTopIpResult::AttackIpDatas> DescribeScdnCcTopIpResult::getAttackIpDataList()const
+{
+	return attackIpDataList_;
+}
+

scdn/src/model/DescribeScdnCcTopUrlRequest.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/scdn/model/DescribeScdnCcTopUrlRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnCcTopUrlRequest;
+
+DescribeScdnCcTopUrlRequest::DescribeScdnCcTopUrlRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnCcTopUrl")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeScdnCcTopUrlRequest::~DescribeScdnCcTopUrlRequest()
+{}
+
+std::string DescribeScdnCcTopUrlRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnCcTopUrlRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnCcTopUrlRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeScdnCcTopUrlRequest::setPageNumber(const std::string& pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", pageNumber);
+}
+
+std::string DescribeScdnCcTopUrlRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeScdnCcTopUrlRequest::setPageSize(const std::string& pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", pageSize);
+}
+
+std::string DescribeScdnCcTopUrlRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnCcTopUrlRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnCcTopUrlRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnCcTopUrlRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeScdnCcTopUrlRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnCcTopUrlRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

scdn/src/model/DescribeScdnCcTopUrlResult.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/scdn/model/DescribeScdnCcTopUrlResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnCcTopUrlResult::DescribeScdnCcTopUrlResult() :
+	ServiceResult()
+{}
+
+DescribeScdnCcTopUrlResult::DescribeScdnCcTopUrlResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnCcTopUrlResult::~DescribeScdnCcTopUrlResult()
+{}
+
+void DescribeScdnCcTopUrlResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAttackUrlDataListNode = value["AttackUrlDataList"]["AttackUrlDatas"];
+	for (auto valueAttackUrlDataListAttackUrlDatas : allAttackUrlDataListNode)
+	{
+		AttackUrlDatas attackUrlDataListObject;
+		if(!valueAttackUrlDataListAttackUrlDatas["Url"].isNull())
+			attackUrlDataListObject.url = valueAttackUrlDataListAttackUrlDatas["Url"].asString();
+		if(!valueAttackUrlDataListAttackUrlDatas["AttackCount"].isNull())
+			attackUrlDataListObject.attackCount = valueAttackUrlDataListAttackUrlDatas["AttackCount"].asString();
+		attackUrlDataList_.push_back(attackUrlDataListObject);
+	}
+	if(!value["Total"].isNull())
+		total_ = value["Total"].asString();
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+
+}
+
+std::string DescribeScdnCcTopUrlResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeScdnCcTopUrlResult::getTotal()const
+{
+	return total_;
+}
+
+std::vector<DescribeScdnCcTopUrlResult::AttackUrlDatas> DescribeScdnCcTopUrlResult::getAttackUrlDataList()const
+{
+	return attackUrlDataList_;
+}
+

scdn/src/model/DescribeScdnCertificateDetailRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnCertificateDetailRequest::getCertName()const
 void DescribeScdnCertificateDetailRequest::setCertName(const std::string& certName)
 {
 	certName_ = certName;
-	setCoreParameter("CertName", certName);
+	setParameter("CertName", certName);
 }
 
 long DescribeScdnCertificateDetailRequest::getOwnerId()const
@@ -46,7 +46,7 @@ long DescribeScdnCertificateDetailRequest::getOwnerId()const
 void DescribeScdnCertificateDetailRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnCertificateDetailRequest::getSecurityToken()const
@@ -57,6 +57,6 @@ std::string DescribeScdnCertificateDetailRequest::getSecurityToken()const
 void DescribeScdnCertificateDetailRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/DescribeScdnCertificateListRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnCertificateListRequest::getDomainName()const
 void DescribeScdnCertificateListRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long DescribeScdnCertificateListRequest::getOwnerId()const
@@ -46,7 +46,7 @@ long DescribeScdnCertificateListRequest::getOwnerId()const
 void DescribeScdnCertificateListRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnCertificateListRequest::getSecurityToken()const
@@ -57,6 +57,6 @@ std::string DescribeScdnCertificateListRequest::getSecurityToken()const
 void DescribeScdnCertificateListRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/DescribeScdnDdosInfoRequest.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/scdn/model/DescribeScdnDdosInfoRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDdosInfoRequest;
+
+DescribeScdnDdosInfoRequest::DescribeScdnDdosInfoRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDdosInfo")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeScdnDdosInfoRequest::~DescribeScdnDdosInfoRequest()
+{}
+
+long DescribeScdnDdosInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDdosInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

scdn/src/model/DescribeScdnDdosInfoResult.cc

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

scdn/src/model/DescribeScdnDdosTrafficInfoRequest.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/scdn/model/DescribeScdnDdosTrafficInfoRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDdosTrafficInfoRequest;
+
+DescribeScdnDdosTrafficInfoRequest::DescribeScdnDdosTrafficInfoRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDdosTrafficInfo")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+DescribeScdnDdosTrafficInfoRequest::~DescribeScdnDdosTrafficInfoRequest()
+{}
+
+std::string DescribeScdnDdosTrafficInfoRequest::getLine()const
+{
+	return line_;
+}
+
+void DescribeScdnDdosTrafficInfoRequest::setLine(const std::string& line)
+{
+	line_ = line;
+	setParameter("Line", line);
+}
+
+std::string DescribeScdnDdosTrafficInfoRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDdosTrafficInfoRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDdosTrafficInfoRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDdosTrafficInfoRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeScdnDdosTrafficInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDdosTrafficInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

scdn/src/model/DescribeScdnDdosTrafficInfoResult.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/scdn/model/DescribeScdnDdosTrafficInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDdosTrafficInfoResult::DescribeScdnDdosTrafficInfoResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDdosTrafficInfoResult::DescribeScdnDdosTrafficInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDdosTrafficInfoResult::~DescribeScdnDdosTrafficInfoResult()
+{}
+
+void DescribeScdnDdosTrafficInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTimeScopesNode = value["TimeScopes"]["TimeScope"];
+	for (auto valueTimeScopesTimeScope : allTimeScopesNode)
+	{
+		TimeScope timeScopesObject;
+		if(!valueTimeScopesTimeScope["Interval"].isNull())
+			timeScopesObject.interval = valueTimeScopesTimeScope["Interval"].asString();
+		if(!valueTimeScopesTimeScope["Start"].isNull())
+			timeScopesObject.start = valueTimeScopesTimeScope["Start"].asString();
+		timeScopes_.push_back(timeScopesObject);
+	}
+	auto allBpsDrops = value["BpsDrops"]["BpsDrop"];
+	for (const auto &item : allBpsDrops)
+		bpsDrops_.push_back(item.asString());
+	auto allBpsTotals = value["BpsTotals"]["BpsTotal"];
+	for (const auto &item : allBpsTotals)
+		bpsTotals_.push_back(item.asString());
+	auto allPpsTotals = value["PpsTotals"]["PpsTotal"];
+	for (const auto &item : allPpsTotals)
+		ppsTotals_.push_back(item.asString());
+	auto allPpsDrops = value["PpsDrops"]["PpsDrop"];
+	for (const auto &item : allPpsDrops)
+		ppsDrops_.push_back(item.asString());
+
+}
+
+std::vector<DescribeScdnDdosTrafficInfoResult::TimeScope> DescribeScdnDdosTrafficInfoResult::getTimeScopes()const
+{
+	return timeScopes_;
+}
+
+std::vector<std::string> DescribeScdnDdosTrafficInfoResult::getBpsDrops()const
+{
+	return bpsDrops_;
+}
+
+std::vector<std::string> DescribeScdnDdosTrafficInfoResult::getPpsDrops()const
+{
+	return ppsDrops_;
+}
+
+std::vector<std::string> DescribeScdnDdosTrafficInfoResult::getBpsTotals()const
+{
+	return bpsTotals_;
+}
+
+std::vector<std::string> DescribeScdnDdosTrafficInfoResult::getPpsTotals()const
+{
+	return ppsTotals_;
+}
+

scdn/src/model/DescribeScdnDomainBpsDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainBpsDataRequest::getLocationNameEn()const
 void DescribeScdnDomainBpsDataRequest::setLocationNameEn(const std::string& locationNameEn)
 {
 	locationNameEn_ = locationNameEn;
-	setCoreParameter("LocationNameEn", locationNameEn);
+	setParameter("LocationNameEn", locationNameEn);
 }
 
 std::string DescribeScdnDomainBpsDataRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainBpsDataRequest::getStartTime()const
 void DescribeScdnDomainBpsDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainBpsDataRequest::getIspNameEn()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainBpsDataRequest::getIspNameEn()const
 void DescribeScdnDomainBpsDataRequest::setIspNameEn(const std::string& ispNameEn)
 {
 	ispNameEn_ = ispNameEn;
-	setCoreParameter("IspNameEn", ispNameEn);
+	setParameter("IspNameEn", ispNameEn);
 }
 
 std::string DescribeScdnDomainBpsDataRequest::getDomainName()const
@@ -68,7 +68,7 @@ std::string DescribeScdnDomainBpsDataRequest::getDomainName()const
 void DescribeScdnDomainBpsDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainBpsDataRequest::getEndTime()const
@@ -79,7 +79,7 @@ std::string DescribeScdnDomainBpsDataRequest::getEndTime()const
 void DescribeScdnDomainBpsDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainBpsDataRequest::getOwnerId()const
@@ -90,7 +90,7 @@ long DescribeScdnDomainBpsDataRequest::getOwnerId()const
 void DescribeScdnDomainBpsDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnDomainBpsDataRequest::getInterval()const
@@ -101,6 +101,6 @@ std::string DescribeScdnDomainBpsDataRequest::getInterval()const
 void DescribeScdnDomainBpsDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

scdn/src/model/DescribeScdnDomainCertificateInfoRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainCertificateInfoRequest::getDomainName()const
 void DescribeScdnDomainCertificateInfoRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long DescribeScdnDomainCertificateInfoRequest::getOwnerId()const
@@ -46,6 +46,6 @@ long DescribeScdnDomainCertificateInfoRequest::getOwnerId()const
 void DescribeScdnDomainCertificateInfoRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainCnameRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainCnameRequest::getDomainName()const
 void DescribeScdnDomainCnameRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long DescribeScdnDomainCnameRequest::getOwnerId()const
@@ -46,6 +46,6 @@ long DescribeScdnDomainCnameRequest::getOwnerId()const
 void DescribeScdnDomainCnameRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainConfigsRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainConfigsRequest::getFunctionNames()const
 void DescribeScdnDomainConfigsRequest::setFunctionNames(const std::string& functionNames)
 {
 	functionNames_ = functionNames;
-	setCoreParameter("FunctionNames", functionNames);
+	setParameter("FunctionNames", functionNames);
 }
 
 std::string DescribeScdnDomainConfigsRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainConfigsRequest::getDomainName()const
 void DescribeScdnDomainConfigsRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long DescribeScdnDomainConfigsRequest::getOwnerId()const
@@ -57,7 +57,7 @@ long DescribeScdnDomainConfigsRequest::getOwnerId()const
 void DescribeScdnDomainConfigsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnDomainConfigsRequest::getSecurityToken()const
@@ -68,6 +68,6 @@ std::string DescribeScdnDomainConfigsRequest::getSecurityToken()const
 void DescribeScdnDomainConfigsRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/DescribeScdnDomainDetailRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainDetailRequest::getDomainName()const
 void DescribeScdnDomainDetailRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long DescribeScdnDomainDetailRequest::getOwnerId()const
@@ -46,7 +46,7 @@ long DescribeScdnDomainDetailRequest::getOwnerId()const
 void DescribeScdnDomainDetailRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnDomainDetailRequest::getSecurityToken()const
@@ -57,6 +57,6 @@ std::string DescribeScdnDomainDetailRequest::getSecurityToken()const
 void DescribeScdnDomainDetailRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/DescribeScdnDomainHitRateDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainHitRateDataRequest::getStartTime()const
 void DescribeScdnDomainHitRateDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainHitRateDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainHitRateDataRequest::getDomainName()const
 void DescribeScdnDomainHitRateDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainHitRateDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainHitRateDataRequest::getEndTime()const
 void DescribeScdnDomainHitRateDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainHitRateDataRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long DescribeScdnDomainHitRateDataRequest::getOwnerId()const
 void DescribeScdnDomainHitRateDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnDomainHitRateDataRequest::getInterval()const
@@ -79,6 +79,6 @@ std::string DescribeScdnDomainHitRateDataRequest::getInterval()const
 void DescribeScdnDomainHitRateDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

scdn/src/model/DescribeScdnDomainHttpCodeDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainHttpCodeDataRequest::getLocationNameEn()const
 void DescribeScdnDomainHttpCodeDataRequest::setLocationNameEn(const std::string& locationNameEn)
 {
 	locationNameEn_ = locationNameEn;
-	setCoreParameter("LocationNameEn", locationNameEn);
+	setParameter("LocationNameEn", locationNameEn);
 }
 
 std::string DescribeScdnDomainHttpCodeDataRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainHttpCodeDataRequest::getStartTime()const
 void DescribeScdnDomainHttpCodeDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainHttpCodeDataRequest::getIspNameEn()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainHttpCodeDataRequest::getIspNameEn()const
 void DescribeScdnDomainHttpCodeDataRequest::setIspNameEn(const std::string& ispNameEn)
 {
 	ispNameEn_ = ispNameEn;
-	setCoreParameter("IspNameEn", ispNameEn);
+	setParameter("IspNameEn", ispNameEn);
 }
 
 std::string DescribeScdnDomainHttpCodeDataRequest::getDomainName()const
@@ -68,7 +68,7 @@ std::string DescribeScdnDomainHttpCodeDataRequest::getDomainName()const
 void DescribeScdnDomainHttpCodeDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainHttpCodeDataRequest::getEndTime()const
@@ -79,7 +79,7 @@ std::string DescribeScdnDomainHttpCodeDataRequest::getEndTime()const
 void DescribeScdnDomainHttpCodeDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainHttpCodeDataRequest::getOwnerId()const
@@ -90,7 +90,7 @@ long DescribeScdnDomainHttpCodeDataRequest::getOwnerId()const
 void DescribeScdnDomainHttpCodeDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnDomainHttpCodeDataRequest::getInterval()const
@@ -101,6 +101,6 @@ std::string DescribeScdnDomainHttpCodeDataRequest::getInterval()const
 void DescribeScdnDomainHttpCodeDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

scdn/src/model/DescribeScdnDomainIspDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainIspDataRequest::getStartTime()const
 void DescribeScdnDomainIspDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainIspDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainIspDataRequest::getDomainName()const
 void DescribeScdnDomainIspDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainIspDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainIspDataRequest::getEndTime()const
 void DescribeScdnDomainIspDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainIspDataRequest::getOwnerId()const
@@ -68,6 +68,6 @@ long DescribeScdnDomainIspDataRequest::getOwnerId()const
 void DescribeScdnDomainIspDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainLogRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainLogRequest::getStartTime()const
 void DescribeScdnDomainLogRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 long DescribeScdnDomainLogRequest::getPageNumber()const
@@ -46,7 +46,7 @@ long DescribeScdnDomainLogRequest::getPageNumber()const
 void DescribeScdnDomainLogRequest::setPageNumber(long pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
 long DescribeScdnDomainLogRequest::getPageSize()const
@@ -57,7 +57,7 @@ long DescribeScdnDomainLogRequest::getPageSize()const
 void DescribeScdnDomainLogRequest::setPageSize(long pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeScdnDomainLogRequest::getDomainName()const
@@ -68,7 +68,7 @@ std::string DescribeScdnDomainLogRequest::getDomainName()const
 void DescribeScdnDomainLogRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainLogRequest::getEndTime()const
@@ -79,7 +79,7 @@ std::string DescribeScdnDomainLogRequest::getEndTime()const
 void DescribeScdnDomainLogRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainLogRequest::getOwnerId()const
@@ -90,6 +90,6 @@ long DescribeScdnDomainLogRequest::getOwnerId()const
 void DescribeScdnDomainLogRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainOriginBpsDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainOriginBpsDataRequest::getStartTime()const
 void DescribeScdnDomainOriginBpsDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainOriginBpsDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainOriginBpsDataRequest::getDomainName()const
 void DescribeScdnDomainOriginBpsDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainOriginBpsDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainOriginBpsDataRequest::getEndTime()const
 void DescribeScdnDomainOriginBpsDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainOriginBpsDataRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long DescribeScdnDomainOriginBpsDataRequest::getOwnerId()const
 void DescribeScdnDomainOriginBpsDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnDomainOriginBpsDataRequest::getInterval()const
@@ -79,6 +79,6 @@ std::string DescribeScdnDomainOriginBpsDataRequest::getInterval()const
 void DescribeScdnDomainOriginBpsDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

scdn/src/model/DescribeScdnDomainOriginTrafficDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainOriginTrafficDataRequest::getStartTime()const
 void DescribeScdnDomainOriginTrafficDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainOriginTrafficDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainOriginTrafficDataRequest::getDomainName()const
 void DescribeScdnDomainOriginTrafficDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainOriginTrafficDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainOriginTrafficDataRequest::getEndTime()const
 void DescribeScdnDomainOriginTrafficDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainOriginTrafficDataRequest::getOwnerId()const
@@ -68,7 +68,7 @@ long DescribeScdnDomainOriginTrafficDataRequest::getOwnerId()const
 void DescribeScdnDomainOriginTrafficDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnDomainOriginTrafficDataRequest::getInterval()const
@@ -79,6 +79,6 @@ std::string DescribeScdnDomainOriginTrafficDataRequest::getInterval()const
 void DescribeScdnDomainOriginTrafficDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

scdn/src/model/DescribeScdnDomainPvDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainPvDataRequest::getStartTime()const
 void DescribeScdnDomainPvDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainPvDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainPvDataRequest::getDomainName()const
 void DescribeScdnDomainPvDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainPvDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainPvDataRequest::getEndTime()const
 void DescribeScdnDomainPvDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainPvDataRequest::getOwnerId()const
@@ -68,6 +68,6 @@ long DescribeScdnDomainPvDataRequest::getOwnerId()const
 void DescribeScdnDomainPvDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainQpsDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainQpsDataRequest::getLocationNameEn()const
 void DescribeScdnDomainQpsDataRequest::setLocationNameEn(const std::string& locationNameEn)
 {
 	locationNameEn_ = locationNameEn;
-	setCoreParameter("LocationNameEn", locationNameEn);
+	setParameter("LocationNameEn", locationNameEn);
 }
 
 std::string DescribeScdnDomainQpsDataRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainQpsDataRequest::getStartTime()const
 void DescribeScdnDomainQpsDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainQpsDataRequest::getIspNameEn()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainQpsDataRequest::getIspNameEn()const
 void DescribeScdnDomainQpsDataRequest::setIspNameEn(const std::string& ispNameEn)
 {
 	ispNameEn_ = ispNameEn;
-	setCoreParameter("IspNameEn", ispNameEn);
+	setParameter("IspNameEn", ispNameEn);
 }
 
 std::string DescribeScdnDomainQpsDataRequest::getDomainName()const
@@ -68,7 +68,7 @@ std::string DescribeScdnDomainQpsDataRequest::getDomainName()const
 void DescribeScdnDomainQpsDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainQpsDataRequest::getEndTime()const
@@ -79,7 +79,7 @@ std::string DescribeScdnDomainQpsDataRequest::getEndTime()const
 void DescribeScdnDomainQpsDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainQpsDataRequest::getOwnerId()const
@@ -90,7 +90,7 @@ long DescribeScdnDomainQpsDataRequest::getOwnerId()const
 void DescribeScdnDomainQpsDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnDomainQpsDataRequest::getInterval()const
@@ -101,6 +101,6 @@ std::string DescribeScdnDomainQpsDataRequest::getInterval()const
 void DescribeScdnDomainQpsDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

scdn/src/model/DescribeScdnDomainRealTimeBpsDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainRealTimeBpsDataRequest::getLocationNameEn()const
 void DescribeScdnDomainRealTimeBpsDataRequest::setLocationNameEn(const std::string& locationNameEn)
 {
 	locationNameEn_ = locationNameEn;
-	setCoreParameter("LocationNameEn", locationNameEn);
+	setParameter("LocationNameEn", locationNameEn);
 }
 
 std::string DescribeScdnDomainRealTimeBpsDataRequest::getIspNameEn()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainRealTimeBpsDataRequest::getIspNameEn()const
 void DescribeScdnDomainRealTimeBpsDataRequest::setIspNameEn(const std::string& ispNameEn)
 {
 	ispNameEn_ = ispNameEn;
-	setCoreParameter("IspNameEn", ispNameEn);
+	setParameter("IspNameEn", ispNameEn);
 }
 
 std::string DescribeScdnDomainRealTimeBpsDataRequest::getStartTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainRealTimeBpsDataRequest::getStartTime()const
 void DescribeScdnDomainRealTimeBpsDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainRealTimeBpsDataRequest::getDomainName()const
@@ -68,7 +68,7 @@ std::string DescribeScdnDomainRealTimeBpsDataRequest::getDomainName()const
 void DescribeScdnDomainRealTimeBpsDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainRealTimeBpsDataRequest::getEndTime()const
@@ -79,7 +79,7 @@ std::string DescribeScdnDomainRealTimeBpsDataRequest::getEndTime()const
 void DescribeScdnDomainRealTimeBpsDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainRealTimeBpsDataRequest::getOwnerId()const
@@ -90,6 +90,6 @@ long DescribeScdnDomainRealTimeBpsDataRequest::getOwnerId()const
 void DescribeScdnDomainRealTimeBpsDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainRealTimeByteHitRateDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getStartTime()cons
 void DescribeScdnDomainRealTimeByteHitRateDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getDomainName()con
 void DescribeScdnDomainRealTimeByteHitRateDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainRealTimeByteHitRateDataRequest::getEndTime()const
 void DescribeScdnDomainRealTimeByteHitRateDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainRealTimeByteHitRateDataRequest::getOwnerId()const
@@ -68,6 +68,6 @@ long DescribeScdnDomainRealTimeByteHitRateDataRequest::getOwnerId()const
 void DescribeScdnDomainRealTimeByteHitRateDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainRealTimeHttpCodeDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getLocationNameEn()co
 void DescribeScdnDomainRealTimeHttpCodeDataRequest::setLocationNameEn(const std::string& locationNameEn)
 {
 	locationNameEn_ = locationNameEn;
-	setCoreParameter("LocationNameEn", locationNameEn);
+	setParameter("LocationNameEn", locationNameEn);
 }
 
 std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getStartTime()const
 void DescribeScdnDomainRealTimeHttpCodeDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getIspNameEn()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getIspNameEn()const
 void DescribeScdnDomainRealTimeHttpCodeDataRequest::setIspNameEn(const std::string& ispNameEn)
 {
 	ispNameEn_ = ispNameEn;
-	setCoreParameter("IspNameEn", ispNameEn);
+	setParameter("IspNameEn", ispNameEn);
 }
 
 std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getDomainName()const
@@ -68,7 +68,7 @@ std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getDomainName()const
 void DescribeScdnDomainRealTimeHttpCodeDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getEndTime()const
@@ -79,7 +79,7 @@ std::string DescribeScdnDomainRealTimeHttpCodeDataRequest::getEndTime()const
 void DescribeScdnDomainRealTimeHttpCodeDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainRealTimeHttpCodeDataRequest::getOwnerId()const
@@ -90,6 +90,6 @@ long DescribeScdnDomainRealTimeHttpCodeDataRequest::getOwnerId()const
 void DescribeScdnDomainRealTimeHttpCodeDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainRealTimeQpsDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainRealTimeQpsDataRequest::getLocationNameEn()const
 void DescribeScdnDomainRealTimeQpsDataRequest::setLocationNameEn(const std::string& locationNameEn)
 {
 	locationNameEn_ = locationNameEn;
-	setCoreParameter("LocationNameEn", locationNameEn);
+	setParameter("LocationNameEn", locationNameEn);
 }
 
 std::string DescribeScdnDomainRealTimeQpsDataRequest::getIspNameEn()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainRealTimeQpsDataRequest::getIspNameEn()const
 void DescribeScdnDomainRealTimeQpsDataRequest::setIspNameEn(const std::string& ispNameEn)
 {
 	ispNameEn_ = ispNameEn;
-	setCoreParameter("IspNameEn", ispNameEn);
+	setParameter("IspNameEn", ispNameEn);
 }
 
 std::string DescribeScdnDomainRealTimeQpsDataRequest::getStartTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainRealTimeQpsDataRequest::getStartTime()const
 void DescribeScdnDomainRealTimeQpsDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainRealTimeQpsDataRequest::getDomainName()const
@@ -68,7 +68,7 @@ std::string DescribeScdnDomainRealTimeQpsDataRequest::getDomainName()const
 void DescribeScdnDomainRealTimeQpsDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainRealTimeQpsDataRequest::getEndTime()const
@@ -79,7 +79,7 @@ std::string DescribeScdnDomainRealTimeQpsDataRequest::getEndTime()const
 void DescribeScdnDomainRealTimeQpsDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainRealTimeQpsDataRequest::getOwnerId()const
@@ -90,6 +90,6 @@ long DescribeScdnDomainRealTimeQpsDataRequest::getOwnerId()const
 void DescribeScdnDomainRealTimeQpsDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainRealTimeReqHitRateDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getStartTime()const
 void DescribeScdnDomainRealTimeReqHitRateDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getDomainName()cons
 void DescribeScdnDomainRealTimeReqHitRateDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainRealTimeReqHitRateDataRequest::getEndTime()const
 void DescribeScdnDomainRealTimeReqHitRateDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainRealTimeReqHitRateDataRequest::getOwnerId()const
@@ -68,6 +68,6 @@ long DescribeScdnDomainRealTimeReqHitRateDataRequest::getOwnerId()const
 void DescribeScdnDomainRealTimeReqHitRateDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainRealTimeSrcBpsDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getStartTime()const
 void DescribeScdnDomainRealTimeSrcBpsDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getDomainName()const
 void DescribeScdnDomainRealTimeSrcBpsDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainRealTimeSrcBpsDataRequest::getEndTime()const
 void DescribeScdnDomainRealTimeSrcBpsDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainRealTimeSrcBpsDataRequest::getOwnerId()const
@@ -68,6 +68,6 @@ long DescribeScdnDomainRealTimeSrcBpsDataRequest::getOwnerId()const
 void DescribeScdnDomainRealTimeSrcBpsDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainRealTimeSrcTrafficDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getStartTime()const
 void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getDomainName()cons
 void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainRealTimeSrcTrafficDataRequest::getEndTime()const
 void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainRealTimeSrcTrafficDataRequest::getOwnerId()const
@@ -68,6 +68,6 @@ long DescribeScdnDomainRealTimeSrcTrafficDataRequest::getOwnerId()const
 void DescribeScdnDomainRealTimeSrcTrafficDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainRealTimeTrafficDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainRealTimeTrafficDataRequest::getStartTime()const
 void DescribeScdnDomainRealTimeTrafficDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainRealTimeTrafficDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainRealTimeTrafficDataRequest::getDomainName()const
 void DescribeScdnDomainRealTimeTrafficDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainRealTimeTrafficDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainRealTimeTrafficDataRequest::getEndTime()const
 void DescribeScdnDomainRealTimeTrafficDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainRealTimeTrafficDataRequest::getOwnerId()const
@@ -68,6 +68,6 @@ long DescribeScdnDomainRealTimeTrafficDataRequest::getOwnerId()const
 void DescribeScdnDomainRealTimeTrafficDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainRegionDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainRegionDataRequest::getStartTime()const
 void DescribeScdnDomainRegionDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainRegionDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainRegionDataRequest::getDomainName()const
 void DescribeScdnDomainRegionDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainRegionDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainRegionDataRequest::getEndTime()const
 void DescribeScdnDomainRegionDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainRegionDataRequest::getOwnerId()const
@@ -68,6 +68,6 @@ long DescribeScdnDomainRegionDataRequest::getOwnerId()const
 void DescribeScdnDomainRegionDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnDomainTopReferVisitRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainTopReferVisitRequest::getDomainName()const
 void DescribeScdnDomainTopReferVisitRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainTopReferVisitRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainTopReferVisitRequest::getStartTime()const
 void DescribeScdnDomainTopReferVisitRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 long DescribeScdnDomainTopReferVisitRequest::getOwnerId()const
@@ -57,7 +57,7 @@ long DescribeScdnDomainTopReferVisitRequest::getOwnerId()const
 void DescribeScdnDomainTopReferVisitRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnDomainTopReferVisitRequest::getSecurityToken()const
@@ -68,7 +68,7 @@ std::string DescribeScdnDomainTopReferVisitRequest::getSecurityToken()const
 void DescribeScdnDomainTopReferVisitRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeScdnDomainTopReferVisitRequest::getSortBy()const
@@ -79,6 +79,6 @@ std::string DescribeScdnDomainTopReferVisitRequest::getSortBy()const
 void DescribeScdnDomainTopReferVisitRequest::setSortBy(const std::string& sortBy)
 {
 	sortBy_ = sortBy;
-	setCoreParameter("SortBy", sortBy);
+	setParameter("SortBy", sortBy);
 }
 

scdn/src/model/DescribeScdnDomainTopUrlVisitRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainTopUrlVisitRequest::getDomainName()const
 void DescribeScdnDomainTopUrlVisitRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainTopUrlVisitRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainTopUrlVisitRequest::getStartTime()const
 void DescribeScdnDomainTopUrlVisitRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 long DescribeScdnDomainTopUrlVisitRequest::getOwnerId()const
@@ -57,7 +57,7 @@ long DescribeScdnDomainTopUrlVisitRequest::getOwnerId()const
 void DescribeScdnDomainTopUrlVisitRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnDomainTopUrlVisitRequest::getSecurityToken()const
@@ -68,7 +68,7 @@ std::string DescribeScdnDomainTopUrlVisitRequest::getSecurityToken()const
 void DescribeScdnDomainTopUrlVisitRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeScdnDomainTopUrlVisitRequest::getSortBy()const
@@ -79,6 +79,6 @@ std::string DescribeScdnDomainTopUrlVisitRequest::getSortBy()const
 void DescribeScdnDomainTopUrlVisitRequest::setSortBy(const std::string& sortBy)
 {
 	sortBy_ = sortBy;
-	setCoreParameter("SortBy", sortBy);
+	setParameter("SortBy", sortBy);
 }
 

scdn/src/model/DescribeScdnDomainTrafficDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainTrafficDataRequest::getLocationNameEn()const
 void DescribeScdnDomainTrafficDataRequest::setLocationNameEn(const std::string& locationNameEn)
 {
 	locationNameEn_ = locationNameEn;
-	setCoreParameter("LocationNameEn", locationNameEn);
+	setParameter("LocationNameEn", locationNameEn);
 }
 
 std::string DescribeScdnDomainTrafficDataRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainTrafficDataRequest::getStartTime()const
 void DescribeScdnDomainTrafficDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainTrafficDataRequest::getIspNameEn()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainTrafficDataRequest::getIspNameEn()const
 void DescribeScdnDomainTrafficDataRequest::setIspNameEn(const std::string& ispNameEn)
 {
 	ispNameEn_ = ispNameEn;
-	setCoreParameter("IspNameEn", ispNameEn);
+	setParameter("IspNameEn", ispNameEn);
 }
 
 std::string DescribeScdnDomainTrafficDataRequest::getDomainName()const
@@ -68,7 +68,7 @@ std::string DescribeScdnDomainTrafficDataRequest::getDomainName()const
 void DescribeScdnDomainTrafficDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainTrafficDataRequest::getEndTime()const
@@ -79,7 +79,7 @@ std::string DescribeScdnDomainTrafficDataRequest::getEndTime()const
 void DescribeScdnDomainTrafficDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainTrafficDataRequest::getOwnerId()const
@@ -90,7 +90,7 @@ long DescribeScdnDomainTrafficDataRequest::getOwnerId()const
 void DescribeScdnDomainTrafficDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnDomainTrafficDataRequest::getInterval()const
@@ -101,6 +101,6 @@ std::string DescribeScdnDomainTrafficDataRequest::getInterval()const
 void DescribeScdnDomainTrafficDataRequest::setInterval(const std::string& interval)
 {
 	interval_ = interval;
-	setCoreParameter("Interval", interval);
+	setParameter("Interval", interval);
 }
 

scdn/src/model/DescribeScdnDomainUvDataRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnDomainUvDataRequest::getStartTime()const
 void DescribeScdnDomainUvDataRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 std::string DescribeScdnDomainUvDataRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string DescribeScdnDomainUvDataRequest::getDomainName()const
 void DescribeScdnDomainUvDataRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnDomainUvDataRequest::getEndTime()const
@@ -57,7 +57,7 @@ std::string DescribeScdnDomainUvDataRequest::getEndTime()const
 void DescribeScdnDomainUvDataRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnDomainUvDataRequest::getOwnerId()const
@@ -68,6 +68,6 @@ long DescribeScdnDomainUvDataRequest::getOwnerId()const
 void DescribeScdnDomainUvDataRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnRefreshQuotaRequest.cc

@@ -35,7 +35,7 @@ long DescribeScdnRefreshQuotaRequest::getOwnerId()const
 void DescribeScdnRefreshQuotaRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnRefreshQuotaRequest::getSecurityToken()const
@@ -46,6 +46,6 @@ std::string DescribeScdnRefreshQuotaRequest::getSecurityToken()const
 void DescribeScdnRefreshQuotaRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/DescribeScdnRefreshTasksRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnRefreshTasksRequest::getObjectPath()const
 void DescribeScdnRefreshTasksRequest::setObjectPath(const std::string& objectPath)
 {
 	objectPath_ = objectPath;
-	setCoreParameter("ObjectPath", objectPath);
+	setParameter("ObjectPath", objectPath);
 }
 
 std::string DescribeScdnRefreshTasksRequest::getStartTime()const
@@ -46,7 +46,7 @@ std::string DescribeScdnRefreshTasksRequest::getStartTime()const
 void DescribeScdnRefreshTasksRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 int DescribeScdnRefreshTasksRequest::getPageNumber()const
@@ -57,7 +57,7 @@ int DescribeScdnRefreshTasksRequest::getPageNumber()const
 void DescribeScdnRefreshTasksRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
 std::string DescribeScdnRefreshTasksRequest::getResourceGroupId()const
@@ -68,7 +68,7 @@ std::string DescribeScdnRefreshTasksRequest::getResourceGroupId()const
 void DescribeScdnRefreshTasksRequest::setResourceGroupId(const std::string& resourceGroupId)
 {
 	resourceGroupId_ = resourceGroupId;
-	setCoreParameter("ResourceGroupId", resourceGroupId);
+	setParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string DescribeScdnRefreshTasksRequest::getSecurityToken()const
@@ -79,7 +79,7 @@ std::string DescribeScdnRefreshTasksRequest::getSecurityToken()const
 void DescribeScdnRefreshTasksRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 int DescribeScdnRefreshTasksRequest::getPageSize()const
@@ -90,7 +90,7 @@ int DescribeScdnRefreshTasksRequest::getPageSize()const
 void DescribeScdnRefreshTasksRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeScdnRefreshTasksRequest::getObjectType()const
@@ -101,7 +101,7 @@ std::string DescribeScdnRefreshTasksRequest::getObjectType()const
 void DescribeScdnRefreshTasksRequest::setObjectType(const std::string& objectType)
 {
 	objectType_ = objectType;
-	setCoreParameter("ObjectType", objectType);
+	setParameter("ObjectType", objectType);
 }
 
 std::string DescribeScdnRefreshTasksRequest::getTaskId()const
@@ -112,7 +112,7 @@ std::string DescribeScdnRefreshTasksRequest::getTaskId()const
 void DescribeScdnRefreshTasksRequest::setTaskId(const std::string& taskId)
 {
 	taskId_ = taskId;
-	setCoreParameter("TaskId", taskId);
+	setParameter("TaskId", taskId);
 }
 
 std::string DescribeScdnRefreshTasksRequest::getDomainName()const
@@ -123,7 +123,7 @@ std::string DescribeScdnRefreshTasksRequest::getDomainName()const
 void DescribeScdnRefreshTasksRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 std::string DescribeScdnRefreshTasksRequest::getEndTime()const
@@ -134,7 +134,7 @@ std::string DescribeScdnRefreshTasksRequest::getEndTime()const
 void DescribeScdnRefreshTasksRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnRefreshTasksRequest::getOwnerId()const
@@ -145,7 +145,7 @@ long DescribeScdnRefreshTasksRequest::getOwnerId()const
 void DescribeScdnRefreshTasksRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnRefreshTasksRequest::getStatus()const
@@ -156,6 +156,6 @@ std::string DescribeScdnRefreshTasksRequest::getStatus()const
 void DescribeScdnRefreshTasksRequest::setStatus(const std::string& status)
 {
 	status_ = status;
-	setCoreParameter("Status", status);
+	setParameter("Status", status);
 }
 

scdn/src/model/DescribeScdnServiceRequest.cc

@@ -35,7 +35,7 @@ long DescribeScdnServiceRequest::getOwnerId()const
 void DescribeScdnServiceRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnServiceRequest::getSecurityToken()const
@@ -46,6 +46,6 @@ std::string DescribeScdnServiceRequest::getSecurityToken()const
 void DescribeScdnServiceRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/DescribeScdnTopDomainsByFlowRequest.cc

@@ -35,7 +35,7 @@ std::string DescribeScdnTopDomainsByFlowRequest::getStartTime()const
 void DescribeScdnTopDomainsByFlowRequest::setStartTime(const std::string& startTime)
 {
 	startTime_ = startTime;
-	setCoreParameter("StartTime", startTime);
+	setParameter("StartTime", startTime);
 }
 
 long DescribeScdnTopDomainsByFlowRequest::getLimit()const
@@ -46,7 +46,7 @@ long DescribeScdnTopDomainsByFlowRequest::getLimit()const
 void DescribeScdnTopDomainsByFlowRequest::setLimit(long limit)
 {
 	limit_ = limit;
-	setCoreParameter("Limit", std::to_string(limit));
+	setParameter("Limit", std::to_string(limit));
 }
 
 std::string DescribeScdnTopDomainsByFlowRequest::getProduct()const
@@ -57,7 +57,7 @@ std::string DescribeScdnTopDomainsByFlowRequest::getProduct()const
 void DescribeScdnTopDomainsByFlowRequest::setProduct(const std::string& product)
 {
 	product_ = product;
-	setCoreParameter("Product", product);
+	setParameter("Product", product);
 }
 
 std::string DescribeScdnTopDomainsByFlowRequest::getEndTime()const
@@ -68,7 +68,7 @@ std::string DescribeScdnTopDomainsByFlowRequest::getEndTime()const
 void DescribeScdnTopDomainsByFlowRequest::setEndTime(const std::string& endTime)
 {
 	endTime_ = endTime;
-	setCoreParameter("EndTime", endTime);
+	setParameter("EndTime", endTime);
 }
 
 long DescribeScdnTopDomainsByFlowRequest::getOwnerId()const
@@ -79,6 +79,6 @@ long DescribeScdnTopDomainsByFlowRequest::getOwnerId()const
 void DescribeScdnTopDomainsByFlowRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 

scdn/src/model/DescribeScdnUserDomainsRequest.cc

@@ -35,7 +35,7 @@ int DescribeScdnUserDomainsRequest::getPageNumber()const
 void DescribeScdnUserDomainsRequest::setPageNumber(int pageNumber)
 {
 	pageNumber_ = pageNumber;
-	setCoreParameter("PageNumber", std::to_string(pageNumber));
+	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
 bool DescribeScdnUserDomainsRequest::getCheckDomainShow()const
@@ -46,7 +46,7 @@ bool DescribeScdnUserDomainsRequest::getCheckDomainShow()const
 void DescribeScdnUserDomainsRequest::setCheckDomainShow(bool checkDomainShow)
 {
 	checkDomainShow_ = checkDomainShow;
-	setCoreParameter("CheckDomainShow", checkDomainShow ? "true" : "false");
+	setParameter("CheckDomainShow", checkDomainShow ? "true" : "false");
 }
 
 std::string DescribeScdnUserDomainsRequest::getResourceGroupId()const
@@ -57,7 +57,7 @@ std::string DescribeScdnUserDomainsRequest::getResourceGroupId()const
 void DescribeScdnUserDomainsRequest::setResourceGroupId(const std::string& resourceGroupId)
 {
 	resourceGroupId_ = resourceGroupId;
-	setCoreParameter("ResourceGroupId", resourceGroupId);
+	setParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string DescribeScdnUserDomainsRequest::getSecurityToken()const
@@ -68,7 +68,7 @@ std::string DescribeScdnUserDomainsRequest::getSecurityToken()const
 void DescribeScdnUserDomainsRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string DescribeScdnUserDomainsRequest::getChangeEndTime()const
@@ -79,7 +79,7 @@ std::string DescribeScdnUserDomainsRequest::getChangeEndTime()const
 void DescribeScdnUserDomainsRequest::setChangeEndTime(const std::string& changeEndTime)
 {
 	changeEndTime_ = changeEndTime;
-	setCoreParameter("ChangeEndTime", changeEndTime);
+	setParameter("ChangeEndTime", changeEndTime);
 }
 
 int DescribeScdnUserDomainsRequest::getPageSize()const
@@ -90,7 +90,7 @@ int DescribeScdnUserDomainsRequest::getPageSize()const
 void DescribeScdnUserDomainsRequest::setPageSize(int pageSize)
 {
 	pageSize_ = pageSize;
-	setCoreParameter("PageSize", std::to_string(pageSize));
+	setParameter("PageSize", std::to_string(pageSize));
 }
 
 std::string DescribeScdnUserDomainsRequest::getFuncFilter()const
@@ -101,7 +101,7 @@ std::string DescribeScdnUserDomainsRequest::getFuncFilter()const
 void DescribeScdnUserDomainsRequest::setFuncFilter(const std::string& funcFilter)
 {
 	funcFilter_ = funcFilter;
-	setCoreParameter("FuncFilter", funcFilter);
+	setParameter("FuncFilter", funcFilter);
 }
 
 std::string DescribeScdnUserDomainsRequest::getDomainName()const
@@ -112,7 +112,7 @@ std::string DescribeScdnUserDomainsRequest::getDomainName()const
 void DescribeScdnUserDomainsRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long DescribeScdnUserDomainsRequest::getOwnerId()const
@@ -123,7 +123,7 @@ long DescribeScdnUserDomainsRequest::getOwnerId()const
 void DescribeScdnUserDomainsRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnUserDomainsRequest::getFuncId()const
@@ -134,7 +134,7 @@ std::string DescribeScdnUserDomainsRequest::getFuncId()const
 void DescribeScdnUserDomainsRequest::setFuncId(const std::string& funcId)
 {
 	funcId_ = funcId;
-	setCoreParameter("FuncId", funcId);
+	setParameter("FuncId", funcId);
 }
 
 std::string DescribeScdnUserDomainsRequest::getDomainStatus()const
@@ -145,7 +145,7 @@ std::string DescribeScdnUserDomainsRequest::getDomainStatus()const
 void DescribeScdnUserDomainsRequest::setDomainStatus(const std::string& domainStatus)
 {
 	domainStatus_ = domainStatus;
-	setCoreParameter("DomainStatus", domainStatus);
+	setParameter("DomainStatus", domainStatus);
 }
 
 std::string DescribeScdnUserDomainsRequest::getDomainSearchType()const
@@ -156,7 +156,7 @@ std::string DescribeScdnUserDomainsRequest::getDomainSearchType()const
 void DescribeScdnUserDomainsRequest::setDomainSearchType(const std::string& domainSearchType)
 {
 	domainSearchType_ = domainSearchType;
-	setCoreParameter("DomainSearchType", domainSearchType);
+	setParameter("DomainSearchType", domainSearchType);
 }
 
 std::string DescribeScdnUserDomainsRequest::getChangeStartTime()const
@@ -167,6 +167,6 @@ std::string DescribeScdnUserDomainsRequest::getChangeStartTime()const
 void DescribeScdnUserDomainsRequest::setChangeStartTime(const std::string& changeStartTime)
 {
 	changeStartTime_ = changeStartTime;
-	setCoreParameter("ChangeStartTime", changeStartTime);
+	setParameter("ChangeStartTime", changeStartTime);
 }
 

scdn/src/model/DescribeScdnUserQuotaRequest.cc

@@ -35,7 +35,7 @@ long DescribeScdnUserQuotaRequest::getOwnerId()const
 void DescribeScdnUserQuotaRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string DescribeScdnUserQuotaRequest::getSecurityToken()const
@@ -46,6 +46,6 @@ std::string DescribeScdnUserQuotaRequest::getSecurityToken()const
 void DescribeScdnUserQuotaRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/OpenScdnServiceRequest.cc

@@ -35,7 +35,7 @@ std::string OpenScdnServiceRequest::getStartDate()const
 void OpenScdnServiceRequest::setStartDate(const std::string& startDate)
 {
 	startDate_ = startDate;
-	setCoreParameter("StartDate", startDate);
+	setParameter("StartDate", startDate);
 }
 
 int OpenScdnServiceRequest::getCcProtection()const
@@ -46,7 +46,7 @@ int OpenScdnServiceRequest::getCcProtection()const
 void OpenScdnServiceRequest::setCcProtection(int ccProtection)
 {
 	ccProtection_ = ccProtection;
-	setCoreParameter("CcProtection", std::to_string(ccProtection));
+	setParameter("CcProtection", std::to_string(ccProtection));
 }
 
 std::string OpenScdnServiceRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string OpenScdnServiceRequest::getSecurityToken()const
 void OpenScdnServiceRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string OpenScdnServiceRequest::getProtectType()const
@@ -68,7 +68,7 @@ std::string OpenScdnServiceRequest::getProtectType()const
 void OpenScdnServiceRequest::setProtectType(const std::string& protectType)
 {
 	protectType_ = protectType;
-	setCoreParameter("ProtectType", protectType);
+	setParameter("ProtectType", protectType);
 }
 
 int OpenScdnServiceRequest::getDDoSBasic()const
@@ -79,7 +79,7 @@ int OpenScdnServiceRequest::getDDoSBasic()const
 void OpenScdnServiceRequest::setDDoSBasic(int dDoSBasic)
 {
 	dDoSBasic_ = dDoSBasic;
-	setCoreParameter("DDoSBasic", std::to_string(dDoSBasic));
+	setParameter("DDoSBasic", std::to_string(dDoSBasic));
 }
 
 int OpenScdnServiceRequest::getBandwidth()const
@@ -90,7 +90,7 @@ int OpenScdnServiceRequest::getBandwidth()const
 void OpenScdnServiceRequest::setBandwidth(int bandwidth)
 {
 	bandwidth_ = bandwidth;
-	setCoreParameter("Bandwidth", std::to_string(bandwidth));
+	setParameter("Bandwidth", std::to_string(bandwidth));
 }
 
 int OpenScdnServiceRequest::getDomainCount()const
@@ -101,7 +101,7 @@ int OpenScdnServiceRequest::getDomainCount()const
 void OpenScdnServiceRequest::setDomainCount(int domainCount)
 {
 	domainCount_ = domainCount;
-	setCoreParameter("DomainCount", std::to_string(domainCount));
+	setParameter("DomainCount", std::to_string(domainCount));
 }
 
 long OpenScdnServiceRequest::getOwnerId()const
@@ -112,7 +112,7 @@ long OpenScdnServiceRequest::getOwnerId()const
 void OpenScdnServiceRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string OpenScdnServiceRequest::getEndDate()const
@@ -123,7 +123,7 @@ std::string OpenScdnServiceRequest::getEndDate()const
 void OpenScdnServiceRequest::setEndDate(const std::string& endDate)
 {
 	endDate_ = endDate;
-	setCoreParameter("EndDate", endDate);
+	setParameter("EndDate", endDate);
 }
 
 int OpenScdnServiceRequest::getElasticProtection()const
@@ -134,6 +134,6 @@ int OpenScdnServiceRequest::getElasticProtection()const
 void OpenScdnServiceRequest::setElasticProtection(int elasticProtection)
 {
 	elasticProtection_ = elasticProtection;
-	setCoreParameter("ElasticProtection", std::to_string(elasticProtection));
+	setParameter("ElasticProtection", std::to_string(elasticProtection));
 }
 

scdn/src/model/PreloadScdnObjectCachesRequest.cc

@@ -35,7 +35,7 @@ std::string PreloadScdnObjectCachesRequest::getArea()const
 void PreloadScdnObjectCachesRequest::setArea(const std::string& area)
 {
 	area_ = area;
-	setCoreParameter("Area", area);
+	setParameter("Area", area);
 }
 
 std::string PreloadScdnObjectCachesRequest::getObjectPath()const
@@ -46,7 +46,7 @@ std::string PreloadScdnObjectCachesRequest::getObjectPath()const
 void PreloadScdnObjectCachesRequest::setObjectPath(const std::string& objectPath)
 {
 	objectPath_ = objectPath;
-	setCoreParameter("ObjectPath", objectPath);
+	setParameter("ObjectPath", objectPath);
 }
 
 long PreloadScdnObjectCachesRequest::getOwnerId()const
@@ -57,7 +57,7 @@ long PreloadScdnObjectCachesRequest::getOwnerId()const
 void PreloadScdnObjectCachesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string PreloadScdnObjectCachesRequest::getSecurityToken()const
@@ -68,6 +68,6 @@ std::string PreloadScdnObjectCachesRequest::getSecurityToken()const
 void PreloadScdnObjectCachesRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/RefreshScdnObjectCachesRequest.cc

@@ -35,7 +35,7 @@ std::string RefreshScdnObjectCachesRequest::getObjectPath()const
 void RefreshScdnObjectCachesRequest::setObjectPath(const std::string& objectPath)
 {
 	objectPath_ = objectPath;
-	setCoreParameter("ObjectPath", objectPath);
+	setParameter("ObjectPath", objectPath);
 }
 
 long RefreshScdnObjectCachesRequest::getOwnerId()const
@@ -46,7 +46,7 @@ long RefreshScdnObjectCachesRequest::getOwnerId()const
 void RefreshScdnObjectCachesRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string RefreshScdnObjectCachesRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string RefreshScdnObjectCachesRequest::getSecurityToken()const
 void RefreshScdnObjectCachesRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string RefreshScdnObjectCachesRequest::getObjectType()const
@@ -68,6 +68,6 @@ std::string RefreshScdnObjectCachesRequest::getObjectType()const
 void RefreshScdnObjectCachesRequest::setObjectType(const std::string& objectType)
 {
 	objectType_ = objectType;
-	setCoreParameter("ObjectType", objectType);
+	setParameter("ObjectType", objectType);
 }
 

scdn/src/model/SetDomainServerCertificateRequest.cc

@@ -35,7 +35,7 @@ std::string SetDomainServerCertificateRequest::getSSLProtocol()const
 void SetDomainServerCertificateRequest::setSSLProtocol(const std::string& sSLProtocol)
 {
 	sSLProtocol_ = sSLProtocol;
-	setCoreParameter("SSLProtocol", sSLProtocol);
+	setParameter("SSLProtocol", sSLProtocol);
 }
 
 std::string SetDomainServerCertificateRequest::getAccessKeyId()const
@@ -46,7 +46,7 @@ std::string SetDomainServerCertificateRequest::getAccessKeyId()const
 void SetDomainServerCertificateRequest::setAccessKeyId(const std::string& accessKeyId)
 {
 	accessKeyId_ = accessKeyId;
-	setCoreParameter("AccessKeyId", accessKeyId);
+	setParameter("AccessKeyId", accessKeyId);
 }
 
 std::string SetDomainServerCertificateRequest::getSecurityToken()const
@@ -57,7 +57,7 @@ std::string SetDomainServerCertificateRequest::getSecurityToken()const
 void SetDomainServerCertificateRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string SetDomainServerCertificateRequest::getSSLPri()const
@@ -68,7 +68,7 @@ std::string SetDomainServerCertificateRequest::getSSLPri()const
 void SetDomainServerCertificateRequest::setSSLPri(const std::string& sSLPri)
 {
 	sSLPri_ = sSLPri;
-	setCoreParameter("SSLPri", sSLPri);
+	setParameter("SSLPri", sSLPri);
 }
 
 std::string SetDomainServerCertificateRequest::getCertName()const
@@ -79,7 +79,7 @@ std::string SetDomainServerCertificateRequest::getCertName()const
 void SetDomainServerCertificateRequest::setCertName(const std::string& certName)
 {
 	certName_ = certName;
-	setCoreParameter("CertName", certName);
+	setParameter("CertName", certName);
 }
 
 std::string SetDomainServerCertificateRequest::getDomainName()const
@@ -90,7 +90,7 @@ std::string SetDomainServerCertificateRequest::getDomainName()const
 void SetDomainServerCertificateRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long SetDomainServerCertificateRequest::getOwnerId()const
@@ -101,7 +101,7 @@ long SetDomainServerCertificateRequest::getOwnerId()const
 void SetDomainServerCertificateRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string SetDomainServerCertificateRequest::getSSLPub()const
@@ -112,7 +112,7 @@ std::string SetDomainServerCertificateRequest::getSSLPub()const
 void SetDomainServerCertificateRequest::setSSLPub(const std::string& sSLPub)
 {
 	sSLPub_ = sSLPub;
-	setCoreParameter("SSLPub", sSLPub);
+	setParameter("SSLPub", sSLPub);
 }
 
 std::string SetDomainServerCertificateRequest::getRegion()const
@@ -123,6 +123,6 @@ std::string SetDomainServerCertificateRequest::getRegion()const
 void SetDomainServerCertificateRequest::setRegion(const std::string& region)
 {
 	region_ = region;
-	setCoreParameter("Region", region);
+	setParameter("Region", region);
 }
 

scdn/src/model/SetScdnBotInfoRequest.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/scdn/model/SetScdnBotInfoRequest.h>
+
+using AlibabaCloud::Scdn::Model::SetScdnBotInfoRequest;
+
+SetScdnBotInfoRequest::SetScdnBotInfoRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "SetScdnBotInfo")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+SetScdnBotInfoRequest::~SetScdnBotInfoRequest()
+{}
+
+std::string SetScdnBotInfoRequest::getEnable()const
+{
+	return enable_;
+}
+
+void SetScdnBotInfoRequest::setEnable(const std::string& enable)
+{
+	enable_ = enable;
+	setParameter("Enable", enable);
+}
+
+std::string SetScdnBotInfoRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void SetScdnBotInfoRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long SetScdnBotInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetScdnBotInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SetScdnBotInfoRequest::getStatus()const
+{
+	return status_;
+}
+
+void SetScdnBotInfoRequest::setStatus(const std::string& status)
+{
+	status_ = status;
+	setParameter("Status", status);
+}
+

scdn/src/model/SetScdnBotInfoResult.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/scdn/model/SetScdnBotInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+SetScdnBotInfoResult::SetScdnBotInfoResult() :
+	ServiceResult()
+{}
+
+SetScdnBotInfoResult::SetScdnBotInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetScdnBotInfoResult::~SetScdnBotInfoResult()
+{}
+
+void SetScdnBotInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

scdn/src/model/SetScdnCcInfoRequest.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/scdn/model/SetScdnCcInfoRequest.h>
+
+using AlibabaCloud::Scdn::Model::SetScdnCcInfoRequest;
+
+SetScdnCcInfoRequest::SetScdnCcInfoRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "SetScdnCcInfo")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+SetScdnCcInfoRequest::~SetScdnCcInfoRequest()
+{}
+
+long SetScdnCcInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetScdnCcInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string SetScdnCcInfoRequest::getStatus()const
+{
+	return status_;
+}
+
+void SetScdnCcInfoRequest::setStatus(const std::string& status)
+{
+	status_ = status;
+	setParameter("Status", status);
+}
+

scdn/src/model/SetScdnCcInfoResult.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/scdn/model/SetScdnCcInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+SetScdnCcInfoResult::SetScdnCcInfoResult() :
+	ServiceResult()
+{}
+
+SetScdnCcInfoResult::SetScdnCcInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetScdnCcInfoResult::~SetScdnCcInfoResult()
+{}
+
+void SetScdnCcInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

scdn/src/model/SetScdnDdosInfoRequest.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/scdn/model/SetScdnDdosInfoRequest.h>
+
+using AlibabaCloud::Scdn::Model::SetScdnDdosInfoRequest;
+
+SetScdnDdosInfoRequest::SetScdnDdosInfoRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "SetScdnDdosInfo")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+SetScdnDdosInfoRequest::~SetScdnDdosInfoRequest()
+{}
+
+long SetScdnDdosInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetScdnDdosInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+int SetScdnDdosInfoRequest::getElasticBandwidth()const
+{
+	return elasticBandwidth_;
+}
+
+void SetScdnDdosInfoRequest::setElasticBandwidth(int elasticBandwidth)
+{
+	elasticBandwidth_ = elasticBandwidth;
+	setParameter("ElasticBandwidth", std::to_string(elasticBandwidth));
+}
+

scdn/src/model/SetScdnDdosInfoResult.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/scdn/model/SetScdnDdosInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+SetScdnDdosInfoResult::SetScdnDdosInfoResult() :
+	ServiceResult()
+{}
+
+SetScdnDdosInfoResult::SetScdnDdosInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetScdnDdosInfoResult::~SetScdnDdosInfoResult()
+{}
+
+void SetScdnDdosInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

scdn/src/model/SetScdnDomainBizInfoRequest.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/scdn/model/SetScdnDomainBizInfoRequest.h>
+
+using AlibabaCloud::Scdn::Model::SetScdnDomainBizInfoRequest;
+
+SetScdnDomainBizInfoRequest::SetScdnDomainBizInfoRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "SetScdnDomainBizInfo")
+{
+	setMethod(HttpRequest::Method::Get);
+}
+
+SetScdnDomainBizInfoRequest::~SetScdnDomainBizInfoRequest()
+{}
+
+std::string SetScdnDomainBizInfoRequest::getBizName()const
+{
+	return bizName_;
+}
+
+void SetScdnDomainBizInfoRequest::setBizName(const std::string& bizName)
+{
+	bizName_ = bizName;
+	setParameter("BizName", bizName);
+}
+
+std::string SetScdnDomainBizInfoRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void SetScdnDomainBizInfoRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long SetScdnDomainBizInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void SetScdnDomainBizInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

scdn/src/model/SetScdnDomainBizInfoResult.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/scdn/model/SetScdnDomainBizInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+SetScdnDomainBizInfoResult::SetScdnDomainBizInfoResult() :
+	ServiceResult()
+{}
+
+SetScdnDomainBizInfoResult::SetScdnDomainBizInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+SetScdnDomainBizInfoResult::~SetScdnDomainBizInfoResult()
+{}
+
+void SetScdnDomainBizInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

scdn/src/model/SetScdnDomainCertificateRequest.cc

@@ -35,7 +35,7 @@ std::string SetScdnDomainCertificateRequest::getSSLProtocol()const
 void SetScdnDomainCertificateRequest::setSSLProtocol(const std::string& sSLProtocol)
 {
 	sSLProtocol_ = sSLProtocol;
-	setCoreParameter("SSLProtocol", sSLProtocol);
+	setParameter("SSLProtocol", sSLProtocol);
 }
 
 std::string SetScdnDomainCertificateRequest::getSecurityToken()const
@@ -46,7 +46,7 @@ std::string SetScdnDomainCertificateRequest::getSecurityToken()const
 void SetScdnDomainCertificateRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 
 std::string SetScdnDomainCertificateRequest::getCertType()const
@@ -57,7 +57,7 @@ std::string SetScdnDomainCertificateRequest::getCertType()const
 void SetScdnDomainCertificateRequest::setCertType(const std::string& certType)
 {
 	certType_ = certType;
-	setCoreParameter("CertType", certType);
+	setParameter("CertType", certType);
 }
 
 std::string SetScdnDomainCertificateRequest::getSSLPri()const
@@ -68,7 +68,7 @@ std::string SetScdnDomainCertificateRequest::getSSLPri()const
 void SetScdnDomainCertificateRequest::setSSLPri(const std::string& sSLPri)
 {
 	sSLPri_ = sSLPri;
-	setCoreParameter("SSLPri", sSLPri);
+	setParameter("SSLPri", sSLPri);
 }
 
 std::string SetScdnDomainCertificateRequest::getForceSet()const
@@ -79,7 +79,7 @@ std::string SetScdnDomainCertificateRequest::getForceSet()const
 void SetScdnDomainCertificateRequest::setForceSet(const std::string& forceSet)
 {
 	forceSet_ = forceSet;
-	setCoreParameter("ForceSet", forceSet);
+	setParameter("ForceSet", forceSet);
 }
 
 std::string SetScdnDomainCertificateRequest::getCertName()const
@@ -90,7 +90,7 @@ std::string SetScdnDomainCertificateRequest::getCertName()const
 void SetScdnDomainCertificateRequest::setCertName(const std::string& certName)
 {
 	certName_ = certName;
-	setCoreParameter("CertName", certName);
+	setParameter("CertName", certName);
 }
 
 std::string SetScdnDomainCertificateRequest::getDomainName()const
@@ -101,7 +101,7 @@ std::string SetScdnDomainCertificateRequest::getDomainName()const
 void SetScdnDomainCertificateRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long SetScdnDomainCertificateRequest::getOwnerId()const
@@ -112,7 +112,7 @@ long SetScdnDomainCertificateRequest::getOwnerId()const
 void SetScdnDomainCertificateRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string SetScdnDomainCertificateRequest::getSSLPub()const
@@ -123,7 +123,7 @@ std::string SetScdnDomainCertificateRequest::getSSLPub()const
 void SetScdnDomainCertificateRequest::setSSLPub(const std::string& sSLPub)
 {
 	sSLPub_ = sSLPub;
-	setCoreParameter("SSLPub", sSLPub);
+	setParameter("SSLPub", sSLPub);
 }
 
 std::string SetScdnDomainCertificateRequest::getRegion()const
@@ -134,6 +134,6 @@ std::string SetScdnDomainCertificateRequest::getRegion()const
 void SetScdnDomainCertificateRequest::setRegion(const std::string& region)
 {
 	region_ = region;
-	setCoreParameter("Region", region);
+	setParameter("Region", region);
 }
 

scdn/src/model/StartScdnDomainRequest.cc

@@ -35,7 +35,7 @@ std::string StartScdnDomainRequest::getDomainName()const
 void StartScdnDomainRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long StartScdnDomainRequest::getOwnerId()const
@@ -46,7 +46,7 @@ long StartScdnDomainRequest::getOwnerId()const
 void StartScdnDomainRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string StartScdnDomainRequest::getSecurityToken()const
@@ -57,6 +57,6 @@ std::string StartScdnDomainRequest::getSecurityToken()const
 void StartScdnDomainRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/StopScdnDomainRequest.cc

@@ -35,7 +35,7 @@ std::string StopScdnDomainRequest::getDomainName()const
 void StopScdnDomainRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long StopScdnDomainRequest::getOwnerId()const
@@ -46,7 +46,7 @@ long StopScdnDomainRequest::getOwnerId()const
 void StopScdnDomainRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string StopScdnDomainRequest::getSecurityToken()const
@@ -57,6 +57,6 @@ std::string StopScdnDomainRequest::getSecurityToken()const
 void StopScdnDomainRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }
 

scdn/src/model/UpdateScdnDomainRequest.cc

@@ -35,7 +35,7 @@ std::string UpdateScdnDomainRequest::getSources()const
 void UpdateScdnDomainRequest::setSources(const std::string& sources)
 {
 	sources_ = sources;
-	setCoreParameter("Sources", sources);
+	setParameter("Sources", sources);
 }
 
 std::string UpdateScdnDomainRequest::getDomainName()const
@@ -46,7 +46,7 @@ std::string UpdateScdnDomainRequest::getDomainName()const
 void UpdateScdnDomainRequest::setDomainName(const std::string& domainName)
 {
 	domainName_ = domainName;
-	setCoreParameter("DomainName", domainName);
+	setParameter("DomainName", domainName);
 }
 
 long UpdateScdnDomainRequest::getOwnerId()const
@@ -57,7 +57,7 @@ long UpdateScdnDomainRequest::getOwnerId()const
 void UpdateScdnDomainRequest::setOwnerId(long ownerId)
 {
 	ownerId_ = ownerId;
-	setCoreParameter("OwnerId", std::to_string(ownerId));
+	setParameter("OwnerId", std::to_string(ownerId));
 }
 
 std::string UpdateScdnDomainRequest::getResourceGroupId()const
@@ -68,7 +68,7 @@ std::string UpdateScdnDomainRequest::getResourceGroupId()const
 void UpdateScdnDomainRequest::setResourceGroupId(const std::string& resourceGroupId)
 {
 	resourceGroupId_ = resourceGroupId;
-	setCoreParameter("ResourceGroupId", resourceGroupId);
+	setParameter("ResourceGroupId", resourceGroupId);
 }
 
 std::string UpdateScdnDomainRequest::getSecurityToken()const
@@ -79,6 +79,6 @@ std::string UpdateScdnDomainRequest::getSecurityToken()const
 void UpdateScdnDomainRequest::setSecurityToken(const std::string& securityToken)
 {
 	securityToken_ = securityToken;
-	setCoreParameter("SecurityToken", securityToken);
+	setParameter("SecurityToken", securityToken);
 }