SCDN SDK Auto Released By xiaoyao,Version：1.17.2

Signed-off-by: haowei.yao <haowei.yao@alibaba-inc.com>

CHANGELOG

@@ -1,3 +1,6 @@
+2018-06-08 Version: 1.17.2
+1, Add scdn interface，support scdn.
+
 2018-06-06 Version: 1.17.1
 1, Change the type of srcUid to int.
 

CMakeLists.txt

@@ -75,4 +75,5 @@ add_subdirectory(pvtz)
 add_subdirectory(cloudauth)
 add_subdirectory(dyvmsapi)
 add_subdirectory(drds)
-add_subdirectory(jarvis)
+add_subdirectory(jarvis)
+add_subdirectory(scdn)

VERSION

@@ -1 +1 @@
-1.17.1
+1.17.2

scdn/CMakeLists.txt

@@ -0,0 +1,198 @@
+#
+# 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.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(scdn_public_header 
+	include/alibabacloud/scdn/ScdnClient.h
+	include/alibabacloud/scdn/ScdnExport.h )
+
+set(scdn_public_header_model 
+	include/alibabacloud/scdn/model/DescribeScdnRefreshQuotaRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnRefreshQuotaResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainTrafficDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainTrafficDataResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainDetailRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainDetailResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainOriginBpsDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainOriginBpsDataResult.h
+	include/alibabacloud/scdn/model/DescribeScdnCertificateListRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnCertificateListResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainQpsDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainQpsDataResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainConfigsRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainConfigsResult.h
+	include/alibabacloud/scdn/model/SetScdnDomainCertificateRequest.h
+	include/alibabacloud/scdn/model/SetScdnDomainCertificateResult.h
+	include/alibabacloud/scdn/model/BatchDeleteScdnDomainConfigsRequest.h
+	include/alibabacloud/scdn/model/BatchDeleteScdnDomainConfigsResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainBpsDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainBpsDataResult.h
+	include/alibabacloud/scdn/model/PreloadScdnObjectCachesRequest.h
+	include/alibabacloud/scdn/model/PreloadScdnObjectCachesResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainHitRateDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainHitRateDataResult.h
+	include/alibabacloud/scdn/model/DescribeScdnUserDomainsRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnUserDomainsResult.h
+	include/alibabacloud/scdn/model/StopScdnDomainRequest.h
+	include/alibabacloud/scdn/model/StopScdnDomainResult.h
+	include/alibabacloud/scdn/model/AddScdnDomainRequest.h
+	include/alibabacloud/scdn/model/AddScdnDomainResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainCnameRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainCnameResult.h
+	include/alibabacloud/scdn/model/DescribeScdnCertificateDetailRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnCertificateDetailResult.h
+	include/alibabacloud/scdn/model/StartScdnDomainRequest.h
+	include/alibabacloud/scdn/model/StartScdnDomainResult.h
+	include/alibabacloud/scdn/model/DeleteScdnDomainRequest.h
+	include/alibabacloud/scdn/model/DeleteScdnDomainResult.h
+	include/alibabacloud/scdn/model/DescribeScdnServiceRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnServiceResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainLogRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainLogResult.h
+	include/alibabacloud/scdn/model/DescribeScdnUserQuotaRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnUserQuotaResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainHttpCodeDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainHttpCodeDataResult.h
+	include/alibabacloud/scdn/model/RefreshScdnObjectCachesRequest.h
+	include/alibabacloud/scdn/model/RefreshScdnObjectCachesResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainCertificateInfoRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainCertificateInfoResult.h
+	include/alibabacloud/scdn/model/CheckScdnServiceRequest.h
+	include/alibabacloud/scdn/model/CheckScdnServiceResult.h
+	include/alibabacloud/scdn/model/UpdateScdnDomainRequest.h
+	include/alibabacloud/scdn/model/UpdateScdnDomainResult.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainOriginTrafficDataRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnDomainOriginTrafficDataResult.h
+	include/alibabacloud/scdn/model/DescribeScdnRefreshTasksRequest.h
+	include/alibabacloud/scdn/model/DescribeScdnRefreshTasksResult.h )
+
+set(scdn_src 
+	src/ScdnClient.cc
+	src/model/DescribeScdnRefreshQuotaRequest.cc
+	src/model/DescribeScdnRefreshQuotaResult.cc
+	src/model/DescribeScdnDomainTrafficDataRequest.cc
+	src/model/DescribeScdnDomainTrafficDataResult.cc
+	src/model/DescribeScdnDomainDetailRequest.cc
+	src/model/DescribeScdnDomainDetailResult.cc
+	src/model/DescribeScdnDomainOriginBpsDataRequest.cc
+	src/model/DescribeScdnDomainOriginBpsDataResult.cc
+	src/model/DescribeScdnCertificateListRequest.cc
+	src/model/DescribeScdnCertificateListResult.cc
+	src/model/DescribeScdnDomainQpsDataRequest.cc
+	src/model/DescribeScdnDomainQpsDataResult.cc
+	src/model/DescribeScdnDomainConfigsRequest.cc
+	src/model/DescribeScdnDomainConfigsResult.cc
+	src/model/SetScdnDomainCertificateRequest.cc
+	src/model/SetScdnDomainCertificateResult.cc
+	src/model/BatchDeleteScdnDomainConfigsRequest.cc
+	src/model/BatchDeleteScdnDomainConfigsResult.cc
+	src/model/DescribeScdnDomainBpsDataRequest.cc
+	src/model/DescribeScdnDomainBpsDataResult.cc
+	src/model/PreloadScdnObjectCachesRequest.cc
+	src/model/PreloadScdnObjectCachesResult.cc
+	src/model/DescribeScdnDomainHitRateDataRequest.cc
+	src/model/DescribeScdnDomainHitRateDataResult.cc
+	src/model/DescribeScdnUserDomainsRequest.cc
+	src/model/DescribeScdnUserDomainsResult.cc
+	src/model/StopScdnDomainRequest.cc
+	src/model/StopScdnDomainResult.cc
+	src/model/AddScdnDomainRequest.cc
+	src/model/AddScdnDomainResult.cc
+	src/model/DescribeScdnDomainCnameRequest.cc
+	src/model/DescribeScdnDomainCnameResult.cc
+	src/model/DescribeScdnCertificateDetailRequest.cc
+	src/model/DescribeScdnCertificateDetailResult.cc
+	src/model/StartScdnDomainRequest.cc
+	src/model/StartScdnDomainResult.cc
+	src/model/DeleteScdnDomainRequest.cc
+	src/model/DeleteScdnDomainResult.cc
+	src/model/DescribeScdnServiceRequest.cc
+	src/model/DescribeScdnServiceResult.cc
+	src/model/DescribeScdnDomainLogRequest.cc
+	src/model/DescribeScdnDomainLogResult.cc
+	src/model/DescribeScdnUserQuotaRequest.cc
+	src/model/DescribeScdnUserQuotaResult.cc
+	src/model/DescribeScdnDomainHttpCodeDataRequest.cc
+	src/model/DescribeScdnDomainHttpCodeDataResult.cc
+	src/model/RefreshScdnObjectCachesRequest.cc
+	src/model/RefreshScdnObjectCachesResult.cc
+	src/model/DescribeScdnDomainCertificateInfoRequest.cc
+	src/model/DescribeScdnDomainCertificateInfoResult.cc
+	src/model/CheckScdnServiceRequest.cc
+	src/model/CheckScdnServiceResult.cc
+	src/model/UpdateScdnDomainRequest.cc
+	src/model/UpdateScdnDomainResult.cc
+	src/model/DescribeScdnDomainOriginTrafficDataRequest.cc
+	src/model/DescribeScdnDomainOriginTrafficDataResult.cc
+	src/model/DescribeScdnRefreshTasksRequest.cc
+	src/model/DescribeScdnRefreshTasksResult.cc )
+
+add_library(scdn ${LIB_TYPE}
+	${scdn_public_header}
+	${scdn_public_header_model}
+	${scdn_src})
+
+set_target_properties(scdn
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}scdn
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(scdn
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_SCDN_LIBRARY)
+endif()
+
+target_include_directories(scdn
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(scdn
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(scdn
+		jsoncpp)
+	target_include_directories(scdn
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(scdn
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(scdn
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(scdn
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(scdn
+		jsoncpp)
+endif()
+
+install(FILES ${scdn_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/scdn)
+install(FILES ${scdn_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/scdn/model)
+install(TARGETS scdn
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

scdn/include/alibabacloud/scdn/ScdnClient.h

@@ -0,0 +1,278 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_SCDNCLIENT_H_
+#define ALIBABACLOUD_SCDN_SCDNCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "ScdnExport.h"
+#include "model/DescribeScdnRefreshQuotaRequest.h"
+#include "model/DescribeScdnRefreshQuotaResult.h"
+#include "model/DescribeScdnDomainTrafficDataRequest.h"
+#include "model/DescribeScdnDomainTrafficDataResult.h"
+#include "model/DescribeScdnDomainDetailRequest.h"
+#include "model/DescribeScdnDomainDetailResult.h"
+#include "model/DescribeScdnDomainOriginBpsDataRequest.h"
+#include "model/DescribeScdnDomainOriginBpsDataResult.h"
+#include "model/DescribeScdnCertificateListRequest.h"
+#include "model/DescribeScdnCertificateListResult.h"
+#include "model/DescribeScdnDomainQpsDataRequest.h"
+#include "model/DescribeScdnDomainQpsDataResult.h"
+#include "model/DescribeScdnDomainConfigsRequest.h"
+#include "model/DescribeScdnDomainConfigsResult.h"
+#include "model/SetScdnDomainCertificateRequest.h"
+#include "model/SetScdnDomainCertificateResult.h"
+#include "model/BatchDeleteScdnDomainConfigsRequest.h"
+#include "model/BatchDeleteScdnDomainConfigsResult.h"
+#include "model/DescribeScdnDomainBpsDataRequest.h"
+#include "model/DescribeScdnDomainBpsDataResult.h"
+#include "model/PreloadScdnObjectCachesRequest.h"
+#include "model/PreloadScdnObjectCachesResult.h"
+#include "model/DescribeScdnDomainHitRateDataRequest.h"
+#include "model/DescribeScdnDomainHitRateDataResult.h"
+#include "model/DescribeScdnUserDomainsRequest.h"
+#include "model/DescribeScdnUserDomainsResult.h"
+#include "model/StopScdnDomainRequest.h"
+#include "model/StopScdnDomainResult.h"
+#include "model/AddScdnDomainRequest.h"
+#include "model/AddScdnDomainResult.h"
+#include "model/DescribeScdnDomainCnameRequest.h"
+#include "model/DescribeScdnDomainCnameResult.h"
+#include "model/DescribeScdnCertificateDetailRequest.h"
+#include "model/DescribeScdnCertificateDetailResult.h"
+#include "model/StartScdnDomainRequest.h"
+#include "model/StartScdnDomainResult.h"
+#include "model/DeleteScdnDomainRequest.h"
+#include "model/DeleteScdnDomainResult.h"
+#include "model/DescribeScdnServiceRequest.h"
+#include "model/DescribeScdnServiceResult.h"
+#include "model/DescribeScdnDomainLogRequest.h"
+#include "model/DescribeScdnDomainLogResult.h"
+#include "model/DescribeScdnUserQuotaRequest.h"
+#include "model/DescribeScdnUserQuotaResult.h"
+#include "model/DescribeScdnDomainHttpCodeDataRequest.h"
+#include "model/DescribeScdnDomainHttpCodeDataResult.h"
+#include "model/RefreshScdnObjectCachesRequest.h"
+#include "model/RefreshScdnObjectCachesResult.h"
+#include "model/DescribeScdnDomainCertificateInfoRequest.h"
+#include "model/DescribeScdnDomainCertificateInfoResult.h"
+#include "model/CheckScdnServiceRequest.h"
+#include "model/CheckScdnServiceResult.h"
+#include "model/UpdateScdnDomainRequest.h"
+#include "model/UpdateScdnDomainResult.h"
+#include "model/DescribeScdnDomainOriginTrafficDataRequest.h"
+#include "model/DescribeScdnDomainOriginTrafficDataResult.h"
+#include "model/DescribeScdnRefreshTasksRequest.h"
+#include "model/DescribeScdnRefreshTasksResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		class ALIBABACLOUD_SCDN_EXPORT ScdnClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::DescribeScdnRefreshQuotaResult> DescribeScdnRefreshQuotaOutcome;
+			typedef std::future<DescribeScdnRefreshQuotaOutcome> DescribeScdnRefreshQuotaOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnRefreshQuotaRequest&, const DescribeScdnRefreshQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnRefreshQuotaAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainTrafficDataResult> DescribeScdnDomainTrafficDataOutcome;
+			typedef std::future<DescribeScdnDomainTrafficDataOutcome> DescribeScdnDomainTrafficDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainTrafficDataRequest&, const DescribeScdnDomainTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainTrafficDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainDetailResult> DescribeScdnDomainDetailOutcome;
+			typedef std::future<DescribeScdnDomainDetailOutcome> DescribeScdnDomainDetailOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainDetailRequest&, const DescribeScdnDomainDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainDetailAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainOriginBpsDataResult> DescribeScdnDomainOriginBpsDataOutcome;
+			typedef std::future<DescribeScdnDomainOriginBpsDataOutcome> DescribeScdnDomainOriginBpsDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainOriginBpsDataRequest&, const DescribeScdnDomainOriginBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainOriginBpsDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnCertificateListResult> DescribeScdnCertificateListOutcome;
+			typedef std::future<DescribeScdnCertificateListOutcome> DescribeScdnCertificateListOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnCertificateListRequest&, const DescribeScdnCertificateListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnCertificateListAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainQpsDataResult> DescribeScdnDomainQpsDataOutcome;
+			typedef std::future<DescribeScdnDomainQpsDataOutcome> DescribeScdnDomainQpsDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainQpsDataRequest&, const DescribeScdnDomainQpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainQpsDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainConfigsResult> DescribeScdnDomainConfigsOutcome;
+			typedef std::future<DescribeScdnDomainConfigsOutcome> DescribeScdnDomainConfigsOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainConfigsRequest&, const DescribeScdnDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainConfigsAsyncHandler;
+			typedef Outcome<Error, Model::SetScdnDomainCertificateResult> SetScdnDomainCertificateOutcome;
+			typedef std::future<SetScdnDomainCertificateOutcome> SetScdnDomainCertificateOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::SetScdnDomainCertificateRequest&, const SetScdnDomainCertificateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SetScdnDomainCertificateAsyncHandler;
+			typedef Outcome<Error, Model::BatchDeleteScdnDomainConfigsResult> BatchDeleteScdnDomainConfigsOutcome;
+			typedef std::future<BatchDeleteScdnDomainConfigsOutcome> BatchDeleteScdnDomainConfigsOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::BatchDeleteScdnDomainConfigsRequest&, const BatchDeleteScdnDomainConfigsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> BatchDeleteScdnDomainConfigsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainBpsDataResult> DescribeScdnDomainBpsDataOutcome;
+			typedef std::future<DescribeScdnDomainBpsDataOutcome> DescribeScdnDomainBpsDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainBpsDataRequest&, const DescribeScdnDomainBpsDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainBpsDataAsyncHandler;
+			typedef Outcome<Error, Model::PreloadScdnObjectCachesResult> PreloadScdnObjectCachesOutcome;
+			typedef std::future<PreloadScdnObjectCachesOutcome> PreloadScdnObjectCachesOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::PreloadScdnObjectCachesRequest&, const PreloadScdnObjectCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PreloadScdnObjectCachesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainHitRateDataResult> DescribeScdnDomainHitRateDataOutcome;
+			typedef std::future<DescribeScdnDomainHitRateDataOutcome> DescribeScdnDomainHitRateDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainHitRateDataRequest&, const DescribeScdnDomainHitRateDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainHitRateDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnUserDomainsResult> DescribeScdnUserDomainsOutcome;
+			typedef std::future<DescribeScdnUserDomainsOutcome> DescribeScdnUserDomainsOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnUserDomainsRequest&, const DescribeScdnUserDomainsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnUserDomainsAsyncHandler;
+			typedef Outcome<Error, Model::StopScdnDomainResult> StopScdnDomainOutcome;
+			typedef std::future<StopScdnDomainOutcome> StopScdnDomainOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::StopScdnDomainRequest&, const StopScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StopScdnDomainAsyncHandler;
+			typedef Outcome<Error, Model::AddScdnDomainResult> AddScdnDomainOutcome;
+			typedef std::future<AddScdnDomainOutcome> AddScdnDomainOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::AddScdnDomainRequest&, const AddScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AddScdnDomainAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainCnameResult> DescribeScdnDomainCnameOutcome;
+			typedef std::future<DescribeScdnDomainCnameOutcome> DescribeScdnDomainCnameOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainCnameRequest&, const DescribeScdnDomainCnameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainCnameAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnCertificateDetailResult> DescribeScdnCertificateDetailOutcome;
+			typedef std::future<DescribeScdnCertificateDetailOutcome> DescribeScdnCertificateDetailOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnCertificateDetailRequest&, const DescribeScdnCertificateDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnCertificateDetailAsyncHandler;
+			typedef Outcome<Error, Model::StartScdnDomainResult> StartScdnDomainOutcome;
+			typedef std::future<StartScdnDomainOutcome> StartScdnDomainOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::StartScdnDomainRequest&, const StartScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StartScdnDomainAsyncHandler;
+			typedef Outcome<Error, Model::DeleteScdnDomainResult> DeleteScdnDomainOutcome;
+			typedef std::future<DeleteScdnDomainOutcome> DeleteScdnDomainOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DeleteScdnDomainRequest&, const DeleteScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteScdnDomainAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnServiceResult> DescribeScdnServiceOutcome;
+			typedef std::future<DescribeScdnServiceOutcome> DescribeScdnServiceOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnServiceRequest&, const DescribeScdnServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnServiceAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainLogResult> DescribeScdnDomainLogOutcome;
+			typedef std::future<DescribeScdnDomainLogOutcome> DescribeScdnDomainLogOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainLogRequest&, const DescribeScdnDomainLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainLogAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnUserQuotaResult> DescribeScdnUserQuotaOutcome;
+			typedef std::future<DescribeScdnUserQuotaOutcome> DescribeScdnUserQuotaOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnUserQuotaRequest&, const DescribeScdnUserQuotaOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnUserQuotaAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainHttpCodeDataResult> DescribeScdnDomainHttpCodeDataOutcome;
+			typedef std::future<DescribeScdnDomainHttpCodeDataOutcome> DescribeScdnDomainHttpCodeDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainHttpCodeDataRequest&, const DescribeScdnDomainHttpCodeDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainHttpCodeDataAsyncHandler;
+			typedef Outcome<Error, Model::RefreshScdnObjectCachesResult> RefreshScdnObjectCachesOutcome;
+			typedef std::future<RefreshScdnObjectCachesOutcome> RefreshScdnObjectCachesOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::RefreshScdnObjectCachesRequest&, const RefreshScdnObjectCachesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RefreshScdnObjectCachesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainCertificateInfoResult> DescribeScdnDomainCertificateInfoOutcome;
+			typedef std::future<DescribeScdnDomainCertificateInfoOutcome> DescribeScdnDomainCertificateInfoOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainCertificateInfoRequest&, const DescribeScdnDomainCertificateInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainCertificateInfoAsyncHandler;
+			typedef Outcome<Error, Model::CheckScdnServiceResult> CheckScdnServiceOutcome;
+			typedef std::future<CheckScdnServiceOutcome> CheckScdnServiceOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::CheckScdnServiceRequest&, const CheckScdnServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckScdnServiceAsyncHandler;
+			typedef Outcome<Error, Model::UpdateScdnDomainResult> UpdateScdnDomainOutcome;
+			typedef std::future<UpdateScdnDomainOutcome> UpdateScdnDomainOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::UpdateScdnDomainRequest&, const UpdateScdnDomainOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateScdnDomainAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnDomainOriginTrafficDataResult> DescribeScdnDomainOriginTrafficDataOutcome;
+			typedef std::future<DescribeScdnDomainOriginTrafficDataOutcome> DescribeScdnDomainOriginTrafficDataOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnDomainOriginTrafficDataRequest&, const DescribeScdnDomainOriginTrafficDataOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnDomainOriginTrafficDataAsyncHandler;
+			typedef Outcome<Error, Model::DescribeScdnRefreshTasksResult> DescribeScdnRefreshTasksOutcome;
+			typedef std::future<DescribeScdnRefreshTasksOutcome> DescribeScdnRefreshTasksOutcomeCallable;
+			typedef std::function<void(const ScdnClient*, const Model::DescribeScdnRefreshTasksRequest&, const DescribeScdnRefreshTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScdnRefreshTasksAsyncHandler;
+
+			ScdnClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			ScdnClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			ScdnClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~ScdnClient();
+			DescribeScdnRefreshQuotaOutcome describeScdnRefreshQuota(const Model::DescribeScdnRefreshQuotaRequest &request)const;
+			void describeScdnRefreshQuotaAsync(const Model::DescribeScdnRefreshQuotaRequest& request, const DescribeScdnRefreshQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnRefreshQuotaOutcomeCallable describeScdnRefreshQuotaCallable(const Model::DescribeScdnRefreshQuotaRequest& request) const;
+			DescribeScdnDomainTrafficDataOutcome describeScdnDomainTrafficData(const Model::DescribeScdnDomainTrafficDataRequest &request)const;
+			void describeScdnDomainTrafficDataAsync(const Model::DescribeScdnDomainTrafficDataRequest& request, const DescribeScdnDomainTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainTrafficDataOutcomeCallable describeScdnDomainTrafficDataCallable(const Model::DescribeScdnDomainTrafficDataRequest& request) const;
+			DescribeScdnDomainDetailOutcome describeScdnDomainDetail(const Model::DescribeScdnDomainDetailRequest &request)const;
+			void describeScdnDomainDetailAsync(const Model::DescribeScdnDomainDetailRequest& request, const DescribeScdnDomainDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainDetailOutcomeCallable describeScdnDomainDetailCallable(const Model::DescribeScdnDomainDetailRequest& request) const;
+			DescribeScdnDomainOriginBpsDataOutcome describeScdnDomainOriginBpsData(const Model::DescribeScdnDomainOriginBpsDataRequest &request)const;
+			void describeScdnDomainOriginBpsDataAsync(const Model::DescribeScdnDomainOriginBpsDataRequest& request, const DescribeScdnDomainOriginBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainOriginBpsDataOutcomeCallable describeScdnDomainOriginBpsDataCallable(const Model::DescribeScdnDomainOriginBpsDataRequest& request) const;
+			DescribeScdnCertificateListOutcome describeScdnCertificateList(const Model::DescribeScdnCertificateListRequest &request)const;
+			void describeScdnCertificateListAsync(const Model::DescribeScdnCertificateListRequest& request, const DescribeScdnCertificateListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnCertificateListOutcomeCallable describeScdnCertificateListCallable(const Model::DescribeScdnCertificateListRequest& request) const;
+			DescribeScdnDomainQpsDataOutcome describeScdnDomainQpsData(const Model::DescribeScdnDomainQpsDataRequest &request)const;
+			void describeScdnDomainQpsDataAsync(const Model::DescribeScdnDomainQpsDataRequest& request, const DescribeScdnDomainQpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainQpsDataOutcomeCallable describeScdnDomainQpsDataCallable(const Model::DescribeScdnDomainQpsDataRequest& request) const;
+			DescribeScdnDomainConfigsOutcome describeScdnDomainConfigs(const Model::DescribeScdnDomainConfigsRequest &request)const;
+			void describeScdnDomainConfigsAsync(const Model::DescribeScdnDomainConfigsRequest& request, const DescribeScdnDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainConfigsOutcomeCallable describeScdnDomainConfigsCallable(const Model::DescribeScdnDomainConfigsRequest& request) const;
+			SetScdnDomainCertificateOutcome setScdnDomainCertificate(const Model::SetScdnDomainCertificateRequest &request)const;
+			void setScdnDomainCertificateAsync(const Model::SetScdnDomainCertificateRequest& request, const SetScdnDomainCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			SetScdnDomainCertificateOutcomeCallable setScdnDomainCertificateCallable(const Model::SetScdnDomainCertificateRequest& request) const;
+			BatchDeleteScdnDomainConfigsOutcome batchDeleteScdnDomainConfigs(const Model::BatchDeleteScdnDomainConfigsRequest &request)const;
+			void batchDeleteScdnDomainConfigsAsync(const Model::BatchDeleteScdnDomainConfigsRequest& request, const BatchDeleteScdnDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			BatchDeleteScdnDomainConfigsOutcomeCallable batchDeleteScdnDomainConfigsCallable(const Model::BatchDeleteScdnDomainConfigsRequest& request) const;
+			DescribeScdnDomainBpsDataOutcome describeScdnDomainBpsData(const Model::DescribeScdnDomainBpsDataRequest &request)const;
+			void describeScdnDomainBpsDataAsync(const Model::DescribeScdnDomainBpsDataRequest& request, const DescribeScdnDomainBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainBpsDataOutcomeCallable describeScdnDomainBpsDataCallable(const Model::DescribeScdnDomainBpsDataRequest& request) const;
+			PreloadScdnObjectCachesOutcome preloadScdnObjectCaches(const Model::PreloadScdnObjectCachesRequest &request)const;
+			void preloadScdnObjectCachesAsync(const Model::PreloadScdnObjectCachesRequest& request, const PreloadScdnObjectCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PreloadScdnObjectCachesOutcomeCallable preloadScdnObjectCachesCallable(const Model::PreloadScdnObjectCachesRequest& request) const;
+			DescribeScdnDomainHitRateDataOutcome describeScdnDomainHitRateData(const Model::DescribeScdnDomainHitRateDataRequest &request)const;
+			void describeScdnDomainHitRateDataAsync(const Model::DescribeScdnDomainHitRateDataRequest& request, const DescribeScdnDomainHitRateDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainHitRateDataOutcomeCallable describeScdnDomainHitRateDataCallable(const Model::DescribeScdnDomainHitRateDataRequest& request) const;
+			DescribeScdnUserDomainsOutcome describeScdnUserDomains(const Model::DescribeScdnUserDomainsRequest &request)const;
+			void describeScdnUserDomainsAsync(const Model::DescribeScdnUserDomainsRequest& request, const DescribeScdnUserDomainsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnUserDomainsOutcomeCallable describeScdnUserDomainsCallable(const Model::DescribeScdnUserDomainsRequest& request) const;
+			StopScdnDomainOutcome stopScdnDomain(const Model::StopScdnDomainRequest &request)const;
+			void stopScdnDomainAsync(const Model::StopScdnDomainRequest& request, const StopScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StopScdnDomainOutcomeCallable stopScdnDomainCallable(const Model::StopScdnDomainRequest& request) const;
+			AddScdnDomainOutcome addScdnDomain(const Model::AddScdnDomainRequest &request)const;
+			void addScdnDomainAsync(const Model::AddScdnDomainRequest& request, const AddScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			AddScdnDomainOutcomeCallable addScdnDomainCallable(const Model::AddScdnDomainRequest& request) const;
+			DescribeScdnDomainCnameOutcome describeScdnDomainCname(const Model::DescribeScdnDomainCnameRequest &request)const;
+			void describeScdnDomainCnameAsync(const Model::DescribeScdnDomainCnameRequest& request, const DescribeScdnDomainCnameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainCnameOutcomeCallable describeScdnDomainCnameCallable(const Model::DescribeScdnDomainCnameRequest& request) const;
+			DescribeScdnCertificateDetailOutcome describeScdnCertificateDetail(const Model::DescribeScdnCertificateDetailRequest &request)const;
+			void describeScdnCertificateDetailAsync(const Model::DescribeScdnCertificateDetailRequest& request, const DescribeScdnCertificateDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnCertificateDetailOutcomeCallable describeScdnCertificateDetailCallable(const Model::DescribeScdnCertificateDetailRequest& request) const;
+			StartScdnDomainOutcome startScdnDomain(const Model::StartScdnDomainRequest &request)const;
+			void startScdnDomainAsync(const Model::StartScdnDomainRequest& request, const StartScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			StartScdnDomainOutcomeCallable startScdnDomainCallable(const Model::StartScdnDomainRequest& request) const;
+			DeleteScdnDomainOutcome deleteScdnDomain(const Model::DeleteScdnDomainRequest &request)const;
+			void deleteScdnDomainAsync(const Model::DeleteScdnDomainRequest& request, const DeleteScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteScdnDomainOutcomeCallable deleteScdnDomainCallable(const Model::DeleteScdnDomainRequest& request) const;
+			DescribeScdnServiceOutcome describeScdnService(const Model::DescribeScdnServiceRequest &request)const;
+			void describeScdnServiceAsync(const Model::DescribeScdnServiceRequest& request, const DescribeScdnServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnServiceOutcomeCallable describeScdnServiceCallable(const Model::DescribeScdnServiceRequest& request) const;
+			DescribeScdnDomainLogOutcome describeScdnDomainLog(const Model::DescribeScdnDomainLogRequest &request)const;
+			void describeScdnDomainLogAsync(const Model::DescribeScdnDomainLogRequest& request, const DescribeScdnDomainLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainLogOutcomeCallable describeScdnDomainLogCallable(const Model::DescribeScdnDomainLogRequest& request) const;
+			DescribeScdnUserQuotaOutcome describeScdnUserQuota(const Model::DescribeScdnUserQuotaRequest &request)const;
+			void describeScdnUserQuotaAsync(const Model::DescribeScdnUserQuotaRequest& request, const DescribeScdnUserQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnUserQuotaOutcomeCallable describeScdnUserQuotaCallable(const Model::DescribeScdnUserQuotaRequest& request) const;
+			DescribeScdnDomainHttpCodeDataOutcome describeScdnDomainHttpCodeData(const Model::DescribeScdnDomainHttpCodeDataRequest &request)const;
+			void describeScdnDomainHttpCodeDataAsync(const Model::DescribeScdnDomainHttpCodeDataRequest& request, const DescribeScdnDomainHttpCodeDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainHttpCodeDataOutcomeCallable describeScdnDomainHttpCodeDataCallable(const Model::DescribeScdnDomainHttpCodeDataRequest& request) const;
+			RefreshScdnObjectCachesOutcome refreshScdnObjectCaches(const Model::RefreshScdnObjectCachesRequest &request)const;
+			void refreshScdnObjectCachesAsync(const Model::RefreshScdnObjectCachesRequest& request, const RefreshScdnObjectCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RefreshScdnObjectCachesOutcomeCallable refreshScdnObjectCachesCallable(const Model::RefreshScdnObjectCachesRequest& request) const;
+			DescribeScdnDomainCertificateInfoOutcome describeScdnDomainCertificateInfo(const Model::DescribeScdnDomainCertificateInfoRequest &request)const;
+			void describeScdnDomainCertificateInfoAsync(const Model::DescribeScdnDomainCertificateInfoRequest& request, const DescribeScdnDomainCertificateInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainCertificateInfoOutcomeCallable describeScdnDomainCertificateInfoCallable(const Model::DescribeScdnDomainCertificateInfoRequest& request) const;
+			CheckScdnServiceOutcome checkScdnService(const Model::CheckScdnServiceRequest &request)const;
+			void checkScdnServiceAsync(const Model::CheckScdnServiceRequest& request, const CheckScdnServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckScdnServiceOutcomeCallable checkScdnServiceCallable(const Model::CheckScdnServiceRequest& request) const;
+			UpdateScdnDomainOutcome updateScdnDomain(const Model::UpdateScdnDomainRequest &request)const;
+			void updateScdnDomainAsync(const Model::UpdateScdnDomainRequest& request, const UpdateScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateScdnDomainOutcomeCallable updateScdnDomainCallable(const Model::UpdateScdnDomainRequest& request) const;
+			DescribeScdnDomainOriginTrafficDataOutcome describeScdnDomainOriginTrafficData(const Model::DescribeScdnDomainOriginTrafficDataRequest &request)const;
+			void describeScdnDomainOriginTrafficDataAsync(const Model::DescribeScdnDomainOriginTrafficDataRequest& request, const DescribeScdnDomainOriginTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnDomainOriginTrafficDataOutcomeCallable describeScdnDomainOriginTrafficDataCallable(const Model::DescribeScdnDomainOriginTrafficDataRequest& request) const;
+			DescribeScdnRefreshTasksOutcome describeScdnRefreshTasks(const Model::DescribeScdnRefreshTasksRequest &request)const;
+			void describeScdnRefreshTasksAsync(const Model::DescribeScdnRefreshTasksRequest& request, const DescribeScdnRefreshTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeScdnRefreshTasksOutcomeCallable describeScdnRefreshTasksCallable(const Model::DescribeScdnRefreshTasksRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_SCDN_SCDNCLIENT_H_

scdn/include/alibabacloud/scdn/ScdnExport.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_SCDNEXPORT_H_
+#define ALIBABACLOUD_SCDN_SCDNEXPORT_H_
+
+#include <alibabacloud/core/Global.h>
+
+#if defined(ALIBABACLOUD_SHARED)
+#	if defined(ALIBABACLOUD_SCDN_LIBRARY)
+#		define ALIBABACLOUD_SCDN_EXPORT ALIBABACLOUD_DECL_EXPORT
+#	else
+#		define ALIBABACLOUD_SCDN_EXPORT ALIBABACLOUD_DECL_IMPORT
+#	endif
+#else
+#	define ALIBABACLOUD_SCDN_EXPORT
+#endif
+
+#endif // !ALIBABACLOUD_SCDN_SCDNEXPORT_H_

scdn/include/alibabacloud/scdn/model/AddScdnDomainRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_ADDSCDNDOMAINREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_ADDSCDNDOMAINREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT AddScdnDomainRequest : public RpcServiceRequest
+			{
+
+			public:
+				AddScdnDomainRequest();
+				~AddScdnDomainRequest();
+
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
+				std::string getSources()const;
+				void setSources(const std::string& sources);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getScope()const;
+				void setScope(const std::string& scope);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getCheckUrl()const;
+				void setCheckUrl(const std::string& checkUrl);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+
+            private:
+				std::string resourceGroupId_;
+				std::string sources_;
+				std::string securityToken_;
+				std::string ownerAccount_;
+				std::string scope_;
+				std::string domainName_;
+				long ownerId_;
+				std::string checkUrl_;
+				std::string accessKeyId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_ADDSCDNDOMAINREQUEST_H_

scdn/include/alibabacloud/scdn/model/AddScdnDomainResult.h

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

scdn/include/alibabacloud/scdn/model/BatchDeleteScdnDomainConfigsRequest.h

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

scdn/include/alibabacloud/scdn/model/BatchDeleteScdnDomainConfigsResult.h

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

scdn/include/alibabacloud/scdn/model/CheckScdnServiceRequest.h

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

scdn/include/alibabacloud/scdn/model/CheckScdnServiceResult.h

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

scdn/include/alibabacloud/scdn/model/DeleteScdnDomainRequest.h

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

scdn/include/alibabacloud/scdn/model/DeleteScdnDomainResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnCertificateDetailRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnCertificateDetailResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnCertificateListRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnCertificateListResult.h

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

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

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainBpsDataResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainCertificateInfoRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainCertificateInfoResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainCnameRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainCnameResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainConfigsRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainConfigsResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainDetailRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainDetailResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainHitRateDataRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainHitRateDataResult.h

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

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

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainHttpCodeDataResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainLogRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainLogResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainOriginBpsDataRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainOriginBpsDataResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainOriginTrafficDataRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainOriginTrafficDataResult.h

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

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

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainQpsDataResult.h

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

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

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

scdn/include/alibabacloud/scdn/model/DescribeScdnDomainTrafficDataResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnRefreshQuotaRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnRefreshQuotaResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnRefreshTasksRequest.h

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHTASKSREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHTASKSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnRefreshTasksRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnRefreshTasksRequest();
+				~DescribeScdnRefreshTasksRequest();
+
+				std::string getObjectPath()const;
+				void setObjectPath(const std::string& objectPath);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getObjectType()const;
+				void setObjectType(const std::string& objectType);
+				std::string getTaskId()const;
+				void setTaskId(const std::string& taskId);
+				std::string getStatus()const;
+				void setStatus(const std::string& status);
+
+            private:
+				std::string objectPath_;
+				std::string domainName_;
+				std::string endTime_;
+				std::string startTime_;
+				long ownerId_;
+				int pageNumber_;
+				std::string accessKeyId_;
+				std::string resourceGroupId_;
+				std::string securityToken_;
+				int pageSize_;
+				std::string objectType_;
+				std::string taskId_;
+				std::string status_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNREFRESHTASKSREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnRefreshTasksResult.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnServiceRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnServiceResult.h

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNSERVICERESULT_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNSERVICERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnServiceResult : public ServiceResult
+			{
+			public:
+				struct LockReason
+				{
+					std::string lockReason;
+				};
+
+
+				DescribeScdnServiceResult();
+				explicit DescribeScdnServiceResult(const std::string &payload);
+				~DescribeScdnServiceResult();
+				std::string getEndTime()const;
+				std::string getInstanceId()const;
+				std::string getPricingCycle()const;
+				std::string getElasticProtection()const;
+				std::string getDDoSBasic()const;
+				std::string getDomainCountValue()const;
+				std::string getProtectTypeValue()const;
+				std::string getCcProtectionValue()const;
+				std::string getCcProtection()const;
+				std::vector<LockReason> getOperationLocks()const;
+				std::string getElasticProtectionValue()const;
+				std::string getOpenTime()const;
+				std::string getBandwidth()const;
+				std::string getDDoSBasicValue()const;
+				std::string getProtectType()const;
+				std::string getBandwidthValue()const;
+				std::string getPriceType()const;
+				std::string getDomainCount()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string endTime_;
+				std::string instanceId_;
+				std::string pricingCycle_;
+				std::string elasticProtection_;
+				std::string dDoSBasic_;
+				std::string domainCountValue_;
+				std::string protectTypeValue_;
+				std::string ccProtectionValue_;
+				std::string ccProtection_;
+				std::vector<LockReason> operationLocks_;
+				std::string elasticProtectionValue_;
+				std::string openTime_;
+				std::string bandwidth_;
+				std::string dDoSBasicValue_;
+				std::string protectType_;
+				std::string bandwidthValue_;
+				std::string priceType_;
+				std::string domainCount_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNSERVICERESULT_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnUserDomainsRequest.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnUserDomainsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeScdnUserDomainsRequest();
+				~DescribeScdnUserDomainsRequest();
+
+				std::string getFuncFilter()const;
+				void setFuncFilter(const std::string& funcFilter);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getFuncId()const;
+				void setFuncId(const std::string& funcId);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getDomainStatus()const;
+				void setDomainStatus(const std::string& domainStatus);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getDomainSearchType()const;
+				void setDomainSearchType(const std::string& domainSearchType);
+				bool getCheckDomainShow()const;
+				void setCheckDomainShow(bool checkDomainShow);
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				std::string funcFilter_;
+				std::string domainName_;
+				long ownerId_;
+				std::string funcId_;
+				int pageNumber_;
+				std::string domainStatus_;
+				std::string accessKeyId_;
+				std::string domainSearchType_;
+				bool checkDomainShow_;
+				std::string resourceGroupId_;
+				std::string securityToken_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSREQUEST_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnUserDomainsResult.h

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSRESULT_H_
+#define ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT DescribeScdnUserDomainsResult : public ServiceResult
+			{
+			public:
+				struct PageData
+				{
+					struct Source
+					{
+						std::string type;
+						std::string content;
+						std::string priority;
+						int port;
+					};
+					std::string description;
+					std::string resourceGroupId;
+					std::string domainName;
+					std::string gmtModified;
+					std::string gmtCreated;
+					std::vector<PageData::Source> sources;
+					std::string cname;
+					std::string domainStatus;
+					std::string sSLProtocol;
+					std::string sandbox;
+				};
+
+
+				DescribeScdnUserDomainsResult();
+				explicit DescribeScdnUserDomainsResult(const std::string &payload);
+				~DescribeScdnUserDomainsResult();
+				std::vector<PageData> getDomains()const;
+				long getTotalCount()const;
+				long getPageSize()const;
+				long getPageNumber()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<PageData> domains_;
+				long totalCount_;
+				long pageSize_;
+				long pageNumber_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_DESCRIBESCDNUSERDOMAINSRESULT_H_

scdn/include/alibabacloud/scdn/model/DescribeScdnUserQuotaRequest.h

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

scdn/include/alibabacloud/scdn/model/DescribeScdnUserQuotaResult.h

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

scdn/include/alibabacloud/scdn/model/PreloadScdnObjectCachesRequest.h

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

scdn/include/alibabacloud/scdn/model/PreloadScdnObjectCachesResult.h

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

scdn/include/alibabacloud/scdn/model/RefreshScdnObjectCachesRequest.h

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

scdn/include/alibabacloud/scdn/model/RefreshScdnObjectCachesResult.h

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

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

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_SCDN_MODEL_SETSCDNDOMAINCERTIFICATEREQUEST_H_
+#define ALIBABACLOUD_SCDN_MODEL_SETSCDNDOMAINCERTIFICATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/scdn/ScdnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Scdn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SCDN_EXPORT SetScdnDomainCertificateRequest : public RpcServiceRequest
+			{
+
+			public:
+				SetScdnDomainCertificateRequest();
+				~SetScdnDomainCertificateRequest();
+
+				std::string getSecurityToken()const;
+				void setSecurityToken(const std::string& securityToken);
+				std::string getCertType()const;
+				void setCertType(const std::string& certType);
+				std::string getSSLPub()const;
+				void setSSLPub(const std::string& sSLPub);
+				std::string getCertName()const;
+				void setCertName(const std::string& certName);
+				std::string getSSLProtocol()const;
+				void setSSLProtocol(const std::string& sSLProtocol);
+				std::string getDomainName()const;
+				void setDomainName(const std::string& domainName);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getRegion()const;
+				void setRegion(const std::string& region);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSSLPri()const;
+				void setSSLPri(const std::string& sSLPri);
+
+            private:
+				std::string securityToken_;
+				std::string certType_;
+				std::string sSLPub_;
+				std::string certName_;
+				std::string sSLProtocol_;
+				std::string domainName_;
+				long ownerId_;
+				std::string region_;
+				std::string accessKeyId_;
+				std::string sSLPri_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SCDN_MODEL_SETSCDNDOMAINCERTIFICATEREQUEST_H_

scdn/include/alibabacloud/scdn/model/SetScdnDomainCertificateResult.h

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

scdn/include/alibabacloud/scdn/model/StartScdnDomainRequest.h

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

scdn/include/alibabacloud/scdn/model/StartScdnDomainResult.h

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

scdn/include/alibabacloud/scdn/model/StopScdnDomainRequest.h

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

scdn/include/alibabacloud/scdn/model/StopScdnDomainResult.h

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

scdn/include/alibabacloud/scdn/model/UpdateScdnDomainRequest.h

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

scdn/include/alibabacloud/scdn/model/UpdateScdnDomainResult.h

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

scdn/src/ScdnClient.cc

@@ -0,0 +1,1097 @@
+/*
+ * 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/ScdnClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "scdn";
+}
+
+ScdnClient::ScdnClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+ScdnClient::ScdnClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+ScdnClient::ScdnClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
+}
+
+ScdnClient::~ScdnClient()
+{}
+
+ScdnClient::DescribeScdnRefreshQuotaOutcome ScdnClient::describeScdnRefreshQuota(const DescribeScdnRefreshQuotaRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnRefreshQuotaOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnRefreshQuotaOutcome(DescribeScdnRefreshQuotaResult(outcome.result()));
+	else
+		return DescribeScdnRefreshQuotaOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnRefreshQuotaAsync(const DescribeScdnRefreshQuotaRequest& request, const DescribeScdnRefreshQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnRefreshQuota(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnRefreshQuotaOutcomeCallable ScdnClient::describeScdnRefreshQuotaCallable(const DescribeScdnRefreshQuotaRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnRefreshQuotaOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnRefreshQuota(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainTrafficDataOutcome ScdnClient::describeScdnDomainTrafficData(const DescribeScdnDomainTrafficDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainTrafficDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainTrafficDataOutcome(DescribeScdnDomainTrafficDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainTrafficDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainTrafficDataAsync(const DescribeScdnDomainTrafficDataRequest& request, const DescribeScdnDomainTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainTrafficData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainTrafficDataOutcomeCallable ScdnClient::describeScdnDomainTrafficDataCallable(const DescribeScdnDomainTrafficDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainTrafficDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainTrafficData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainDetailOutcome ScdnClient::describeScdnDomainDetail(const DescribeScdnDomainDetailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainDetailOutcome(DescribeScdnDomainDetailResult(outcome.result()));
+	else
+		return DescribeScdnDomainDetailOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainDetailAsync(const DescribeScdnDomainDetailRequest& request, const DescribeScdnDomainDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainDetailOutcomeCallable ScdnClient::describeScdnDomainDetailCallable(const DescribeScdnDomainDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainOriginBpsDataOutcome ScdnClient::describeScdnDomainOriginBpsData(const DescribeScdnDomainOriginBpsDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainOriginBpsDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainOriginBpsDataOutcome(DescribeScdnDomainOriginBpsDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainOriginBpsDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainOriginBpsDataAsync(const DescribeScdnDomainOriginBpsDataRequest& request, const DescribeScdnDomainOriginBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainOriginBpsData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainOriginBpsDataOutcomeCallable ScdnClient::describeScdnDomainOriginBpsDataCallable(const DescribeScdnDomainOriginBpsDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainOriginBpsDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainOriginBpsData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnCertificateListOutcome ScdnClient::describeScdnCertificateList(const DescribeScdnCertificateListRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnCertificateListOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnCertificateListOutcome(DescribeScdnCertificateListResult(outcome.result()));
+	else
+		return DescribeScdnCertificateListOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnCertificateListAsync(const DescribeScdnCertificateListRequest& request, const DescribeScdnCertificateListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnCertificateList(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnCertificateListOutcomeCallable ScdnClient::describeScdnCertificateListCallable(const DescribeScdnCertificateListRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnCertificateListOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnCertificateList(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainQpsDataOutcome ScdnClient::describeScdnDomainQpsData(const DescribeScdnDomainQpsDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainQpsDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainQpsDataOutcome(DescribeScdnDomainQpsDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainQpsDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainQpsDataAsync(const DescribeScdnDomainQpsDataRequest& request, const DescribeScdnDomainQpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainQpsData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainQpsDataOutcomeCallable ScdnClient::describeScdnDomainQpsDataCallable(const DescribeScdnDomainQpsDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainQpsDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainQpsData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainConfigsOutcome ScdnClient::describeScdnDomainConfigs(const DescribeScdnDomainConfigsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainConfigsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainConfigsOutcome(DescribeScdnDomainConfigsResult(outcome.result()));
+	else
+		return DescribeScdnDomainConfigsOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainConfigsAsync(const DescribeScdnDomainConfigsRequest& request, const DescribeScdnDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainConfigs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainConfigsOutcomeCallable ScdnClient::describeScdnDomainConfigsCallable(const DescribeScdnDomainConfigsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainConfigsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainConfigs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::SetScdnDomainCertificateOutcome ScdnClient::setScdnDomainCertificate(const SetScdnDomainCertificateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return SetScdnDomainCertificateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return SetScdnDomainCertificateOutcome(SetScdnDomainCertificateResult(outcome.result()));
+	else
+		return SetScdnDomainCertificateOutcome(outcome.error());
+}
+
+void ScdnClient::setScdnDomainCertificateAsync(const SetScdnDomainCertificateRequest& request, const SetScdnDomainCertificateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, setScdnDomainCertificate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::SetScdnDomainCertificateOutcomeCallable ScdnClient::setScdnDomainCertificateCallable(const SetScdnDomainCertificateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<SetScdnDomainCertificateOutcome()>>(
+			[this, request]()
+			{
+			return this->setScdnDomainCertificate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::BatchDeleteScdnDomainConfigsOutcome ScdnClient::batchDeleteScdnDomainConfigs(const BatchDeleteScdnDomainConfigsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BatchDeleteScdnDomainConfigsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BatchDeleteScdnDomainConfigsOutcome(BatchDeleteScdnDomainConfigsResult(outcome.result()));
+	else
+		return BatchDeleteScdnDomainConfigsOutcome(outcome.error());
+}
+
+void ScdnClient::batchDeleteScdnDomainConfigsAsync(const BatchDeleteScdnDomainConfigsRequest& request, const BatchDeleteScdnDomainConfigsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, batchDeleteScdnDomainConfigs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::BatchDeleteScdnDomainConfigsOutcomeCallable ScdnClient::batchDeleteScdnDomainConfigsCallable(const BatchDeleteScdnDomainConfigsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BatchDeleteScdnDomainConfigsOutcome()>>(
+			[this, request]()
+			{
+			return this->batchDeleteScdnDomainConfigs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainBpsDataOutcome ScdnClient::describeScdnDomainBpsData(const DescribeScdnDomainBpsDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainBpsDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainBpsDataOutcome(DescribeScdnDomainBpsDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainBpsDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainBpsDataAsync(const DescribeScdnDomainBpsDataRequest& request, const DescribeScdnDomainBpsDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainBpsData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainBpsDataOutcomeCallable ScdnClient::describeScdnDomainBpsDataCallable(const DescribeScdnDomainBpsDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainBpsDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainBpsData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::PreloadScdnObjectCachesOutcome ScdnClient::preloadScdnObjectCaches(const PreloadScdnObjectCachesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PreloadScdnObjectCachesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PreloadScdnObjectCachesOutcome(PreloadScdnObjectCachesResult(outcome.result()));
+	else
+		return PreloadScdnObjectCachesOutcome(outcome.error());
+}
+
+void ScdnClient::preloadScdnObjectCachesAsync(const PreloadScdnObjectCachesRequest& request, const PreloadScdnObjectCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, preloadScdnObjectCaches(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::PreloadScdnObjectCachesOutcomeCallable ScdnClient::preloadScdnObjectCachesCallable(const PreloadScdnObjectCachesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PreloadScdnObjectCachesOutcome()>>(
+			[this, request]()
+			{
+			return this->preloadScdnObjectCaches(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainHitRateDataOutcome ScdnClient::describeScdnDomainHitRateData(const DescribeScdnDomainHitRateDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainHitRateDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainHitRateDataOutcome(DescribeScdnDomainHitRateDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainHitRateDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainHitRateDataAsync(const DescribeScdnDomainHitRateDataRequest& request, const DescribeScdnDomainHitRateDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainHitRateData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainHitRateDataOutcomeCallable ScdnClient::describeScdnDomainHitRateDataCallable(const DescribeScdnDomainHitRateDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainHitRateDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainHitRateData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnUserDomainsOutcome ScdnClient::describeScdnUserDomains(const DescribeScdnUserDomainsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnUserDomainsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnUserDomainsOutcome(DescribeScdnUserDomainsResult(outcome.result()));
+	else
+		return DescribeScdnUserDomainsOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnUserDomainsAsync(const DescribeScdnUserDomainsRequest& request, const DescribeScdnUserDomainsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnUserDomains(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnUserDomainsOutcomeCallable ScdnClient::describeScdnUserDomainsCallable(const DescribeScdnUserDomainsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnUserDomainsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnUserDomains(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::StopScdnDomainOutcome ScdnClient::stopScdnDomain(const StopScdnDomainRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StopScdnDomainOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StopScdnDomainOutcome(StopScdnDomainResult(outcome.result()));
+	else
+		return StopScdnDomainOutcome(outcome.error());
+}
+
+void ScdnClient::stopScdnDomainAsync(const StopScdnDomainRequest& request, const StopScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, stopScdnDomain(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::StopScdnDomainOutcomeCallable ScdnClient::stopScdnDomainCallable(const StopScdnDomainRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StopScdnDomainOutcome()>>(
+			[this, request]()
+			{
+			return this->stopScdnDomain(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::AddScdnDomainOutcome ScdnClient::addScdnDomain(const AddScdnDomainRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return AddScdnDomainOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return AddScdnDomainOutcome(AddScdnDomainResult(outcome.result()));
+	else
+		return AddScdnDomainOutcome(outcome.error());
+}
+
+void ScdnClient::addScdnDomainAsync(const AddScdnDomainRequest& request, const AddScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, addScdnDomain(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::AddScdnDomainOutcomeCallable ScdnClient::addScdnDomainCallable(const AddScdnDomainRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<AddScdnDomainOutcome()>>(
+			[this, request]()
+			{
+			return this->addScdnDomain(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainCnameOutcome ScdnClient::describeScdnDomainCname(const DescribeScdnDomainCnameRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainCnameOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainCnameOutcome(DescribeScdnDomainCnameResult(outcome.result()));
+	else
+		return DescribeScdnDomainCnameOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainCnameAsync(const DescribeScdnDomainCnameRequest& request, const DescribeScdnDomainCnameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainCname(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainCnameOutcomeCallable ScdnClient::describeScdnDomainCnameCallable(const DescribeScdnDomainCnameRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainCnameOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainCname(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnCertificateDetailOutcome ScdnClient::describeScdnCertificateDetail(const DescribeScdnCertificateDetailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnCertificateDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnCertificateDetailOutcome(DescribeScdnCertificateDetailResult(outcome.result()));
+	else
+		return DescribeScdnCertificateDetailOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnCertificateDetailAsync(const DescribeScdnCertificateDetailRequest& request, const DescribeScdnCertificateDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnCertificateDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnCertificateDetailOutcomeCallable ScdnClient::describeScdnCertificateDetailCallable(const DescribeScdnCertificateDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnCertificateDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnCertificateDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::StartScdnDomainOutcome ScdnClient::startScdnDomain(const StartScdnDomainRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return StartScdnDomainOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return StartScdnDomainOutcome(StartScdnDomainResult(outcome.result()));
+	else
+		return StartScdnDomainOutcome(outcome.error());
+}
+
+void ScdnClient::startScdnDomainAsync(const StartScdnDomainRequest& request, const StartScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, startScdnDomain(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::StartScdnDomainOutcomeCallable ScdnClient::startScdnDomainCallable(const StartScdnDomainRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<StartScdnDomainOutcome()>>(
+			[this, request]()
+			{
+			return this->startScdnDomain(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DeleteScdnDomainOutcome ScdnClient::deleteScdnDomain(const DeleteScdnDomainRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteScdnDomainOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteScdnDomainOutcome(DeleteScdnDomainResult(outcome.result()));
+	else
+		return DeleteScdnDomainOutcome(outcome.error());
+}
+
+void ScdnClient::deleteScdnDomainAsync(const DeleteScdnDomainRequest& request, const DeleteScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteScdnDomain(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DeleteScdnDomainOutcomeCallable ScdnClient::deleteScdnDomainCallable(const DeleteScdnDomainRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteScdnDomainOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteScdnDomain(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnServiceOutcome ScdnClient::describeScdnService(const DescribeScdnServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnServiceOutcome(DescribeScdnServiceResult(outcome.result()));
+	else
+		return DescribeScdnServiceOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnServiceAsync(const DescribeScdnServiceRequest& request, const DescribeScdnServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnServiceOutcomeCallable ScdnClient::describeScdnServiceCallable(const DescribeScdnServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainLogOutcome ScdnClient::describeScdnDomainLog(const DescribeScdnDomainLogRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainLogOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainLogOutcome(DescribeScdnDomainLogResult(outcome.result()));
+	else
+		return DescribeScdnDomainLogOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainLogAsync(const DescribeScdnDomainLogRequest& request, const DescribeScdnDomainLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainLog(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainLogOutcomeCallable ScdnClient::describeScdnDomainLogCallable(const DescribeScdnDomainLogRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainLogOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainLog(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnUserQuotaOutcome ScdnClient::describeScdnUserQuota(const DescribeScdnUserQuotaRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnUserQuotaOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnUserQuotaOutcome(DescribeScdnUserQuotaResult(outcome.result()));
+	else
+		return DescribeScdnUserQuotaOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnUserQuotaAsync(const DescribeScdnUserQuotaRequest& request, const DescribeScdnUserQuotaAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnUserQuota(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnUserQuotaOutcomeCallable ScdnClient::describeScdnUserQuotaCallable(const DescribeScdnUserQuotaRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnUserQuotaOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnUserQuota(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainHttpCodeDataOutcome ScdnClient::describeScdnDomainHttpCodeData(const DescribeScdnDomainHttpCodeDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainHttpCodeDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainHttpCodeDataOutcome(DescribeScdnDomainHttpCodeDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainHttpCodeDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainHttpCodeDataAsync(const DescribeScdnDomainHttpCodeDataRequest& request, const DescribeScdnDomainHttpCodeDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainHttpCodeData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainHttpCodeDataOutcomeCallable ScdnClient::describeScdnDomainHttpCodeDataCallable(const DescribeScdnDomainHttpCodeDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainHttpCodeDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainHttpCodeData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::RefreshScdnObjectCachesOutcome ScdnClient::refreshScdnObjectCaches(const RefreshScdnObjectCachesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RefreshScdnObjectCachesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RefreshScdnObjectCachesOutcome(RefreshScdnObjectCachesResult(outcome.result()));
+	else
+		return RefreshScdnObjectCachesOutcome(outcome.error());
+}
+
+void ScdnClient::refreshScdnObjectCachesAsync(const RefreshScdnObjectCachesRequest& request, const RefreshScdnObjectCachesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, refreshScdnObjectCaches(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::RefreshScdnObjectCachesOutcomeCallable ScdnClient::refreshScdnObjectCachesCallable(const RefreshScdnObjectCachesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RefreshScdnObjectCachesOutcome()>>(
+			[this, request]()
+			{
+			return this->refreshScdnObjectCaches(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainCertificateInfoOutcome ScdnClient::describeScdnDomainCertificateInfo(const DescribeScdnDomainCertificateInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainCertificateInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainCertificateInfoOutcome(DescribeScdnDomainCertificateInfoResult(outcome.result()));
+	else
+		return DescribeScdnDomainCertificateInfoOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainCertificateInfoAsync(const DescribeScdnDomainCertificateInfoRequest& request, const DescribeScdnDomainCertificateInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainCertificateInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainCertificateInfoOutcomeCallable ScdnClient::describeScdnDomainCertificateInfoCallable(const DescribeScdnDomainCertificateInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainCertificateInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainCertificateInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::CheckScdnServiceOutcome ScdnClient::checkScdnService(const CheckScdnServiceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CheckScdnServiceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CheckScdnServiceOutcome(CheckScdnServiceResult(outcome.result()));
+	else
+		return CheckScdnServiceOutcome(outcome.error());
+}
+
+void ScdnClient::checkScdnServiceAsync(const CheckScdnServiceRequest& request, const CheckScdnServiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, checkScdnService(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::CheckScdnServiceOutcomeCallable ScdnClient::checkScdnServiceCallable(const CheckScdnServiceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CheckScdnServiceOutcome()>>(
+			[this, request]()
+			{
+			return this->checkScdnService(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::UpdateScdnDomainOutcome ScdnClient::updateScdnDomain(const UpdateScdnDomainRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UpdateScdnDomainOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UpdateScdnDomainOutcome(UpdateScdnDomainResult(outcome.result()));
+	else
+		return UpdateScdnDomainOutcome(outcome.error());
+}
+
+void ScdnClient::updateScdnDomainAsync(const UpdateScdnDomainRequest& request, const UpdateScdnDomainAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, updateScdnDomain(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::UpdateScdnDomainOutcomeCallable ScdnClient::updateScdnDomainCallable(const UpdateScdnDomainRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UpdateScdnDomainOutcome()>>(
+			[this, request]()
+			{
+			return this->updateScdnDomain(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnDomainOriginTrafficDataOutcome ScdnClient::describeScdnDomainOriginTrafficData(const DescribeScdnDomainOriginTrafficDataRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnDomainOriginTrafficDataOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnDomainOriginTrafficDataOutcome(DescribeScdnDomainOriginTrafficDataResult(outcome.result()));
+	else
+		return DescribeScdnDomainOriginTrafficDataOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnDomainOriginTrafficDataAsync(const DescribeScdnDomainOriginTrafficDataRequest& request, const DescribeScdnDomainOriginTrafficDataAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnDomainOriginTrafficData(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnDomainOriginTrafficDataOutcomeCallable ScdnClient::describeScdnDomainOriginTrafficDataCallable(const DescribeScdnDomainOriginTrafficDataRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnDomainOriginTrafficDataOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnDomainOriginTrafficData(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+ScdnClient::DescribeScdnRefreshTasksOutcome ScdnClient::describeScdnRefreshTasks(const DescribeScdnRefreshTasksRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeScdnRefreshTasksOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeScdnRefreshTasksOutcome(DescribeScdnRefreshTasksResult(outcome.result()));
+	else
+		return DescribeScdnRefreshTasksOutcome(outcome.error());
+}
+
+void ScdnClient::describeScdnRefreshTasksAsync(const DescribeScdnRefreshTasksRequest& request, const DescribeScdnRefreshTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeScdnRefreshTasks(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+ScdnClient::DescribeScdnRefreshTasksOutcomeCallable ScdnClient::describeScdnRefreshTasksCallable(const DescribeScdnRefreshTasksRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeScdnRefreshTasksOutcome()>>(
+			[this, request]()
+			{
+			return this->describeScdnRefreshTasks(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

scdn/src/model/AddScdnDomainRequest.cc

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

scdn/src/model/AddScdnDomainResult.cc

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

scdn/src/model/BatchDeleteScdnDomainConfigsRequest.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/BatchDeleteScdnDomainConfigsRequest.h>
+
+using AlibabaCloud::Scdn::Model::BatchDeleteScdnDomainConfigsRequest;
+
+BatchDeleteScdnDomainConfigsRequest::BatchDeleteScdnDomainConfigsRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "BatchDeleteScdnDomainConfigs")
+{}
+
+BatchDeleteScdnDomainConfigsRequest::~BatchDeleteScdnDomainConfigsRequest()
+{}
+
+std::string BatchDeleteScdnDomainConfigsRequest::getFunctionNames()const
+{
+	return functionNames_;
+}
+
+void BatchDeleteScdnDomainConfigsRequest::setFunctionNames(const std::string& functionNames)
+{
+	functionNames_ = functionNames;
+	setParameter("FunctionNames", functionNames);
+}
+
+std::string BatchDeleteScdnDomainConfigsRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void BatchDeleteScdnDomainConfigsRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string BatchDeleteScdnDomainConfigsRequest::getDomainNames()const
+{
+	return domainNames_;
+}
+
+void BatchDeleteScdnDomainConfigsRequest::setDomainNames(const std::string& domainNames)
+{
+	domainNames_ = domainNames;
+	setParameter("DomainNames", domainNames);
+}
+
+std::string BatchDeleteScdnDomainConfigsRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void BatchDeleteScdnDomainConfigsRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long BatchDeleteScdnDomainConfigsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void BatchDeleteScdnDomainConfigsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string BatchDeleteScdnDomainConfigsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void BatchDeleteScdnDomainConfigsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

scdn/src/model/BatchDeleteScdnDomainConfigsResult.cc

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

scdn/src/model/CheckScdnServiceRequest.cc

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

scdn/src/model/CheckScdnServiceResult.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/CheckScdnServiceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+CheckScdnServiceResult::CheckScdnServiceResult() :
+	ServiceResult()
+{}
+
+CheckScdnServiceResult::CheckScdnServiceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CheckScdnServiceResult::~CheckScdnServiceResult()
+{}
+
+void CheckScdnServiceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["Enabled"].isNull())
+		enabled_ = value["Enabled"].asString() == "true";
+	if(!value["OnService"].isNull())
+		onService_ = value["OnService"].asString() == "true";
+	if(!value["InDebt"].isNull())
+		inDebt_ = value["InDebt"].asString() == "true";
+	if(!value["InDebtOverdue"].isNull())
+		inDebtOverdue_ = value["InDebtOverdue"].asString() == "true";
+
+}
+
+bool CheckScdnServiceResult::getInDebt()const
+{
+	return inDebt_;
+}
+
+bool CheckScdnServiceResult::getEnabled()const
+{
+	return enabled_;
+}
+
+bool CheckScdnServiceResult::getInDebtOverdue()const
+{
+	return inDebtOverdue_;
+}
+
+bool CheckScdnServiceResult::getOnService()const
+{
+	return onService_;
+}
+

scdn/src/model/DeleteScdnDomainRequest.cc

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

scdn/src/model/DeleteScdnDomainResult.cc

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

scdn/src/model/DescribeScdnCertificateDetailRequest.cc

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

scdn/src/model/DescribeScdnCertificateDetailResult.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/DescribeScdnCertificateDetailResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnCertificateDetailResult::DescribeScdnCertificateDetailResult() :
+	ServiceResult()
+{}
+
+DescribeScdnCertificateDetailResult::DescribeScdnCertificateDetailResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnCertificateDetailResult::~DescribeScdnCertificateDetailResult()
+{}
+
+void DescribeScdnCertificateDetailResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	if(!value["Cert"].isNull())
+		cert_ = value["Cert"].asString();
+	if(!value["Key"].isNull())
+		key_ = value["Key"].asString();
+	if(!value["CertId"].isNull())
+		certId_ = std::stol(value["CertId"].asString());
+	if(!value["CertName"].isNull())
+		certName_ = value["CertName"].asString();
+
+}
+
+long DescribeScdnCertificateDetailResult::getCertId()const
+{
+	return certId_;
+}
+
+std::string DescribeScdnCertificateDetailResult::getCert()const
+{
+	return cert_;
+}
+
+std::string DescribeScdnCertificateDetailResult::getCertName()const
+{
+	return certName_;
+}
+
+std::string DescribeScdnCertificateDetailResult::getKey()const
+{
+	return key_;
+}
+

scdn/src/model/DescribeScdnCertificateListRequest.cc

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

scdn/src/model/DescribeScdnCertificateListResult.cc

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnCertificateListResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnCertificateListResult::DescribeScdnCertificateListResult() :
+	ServiceResult()
+{}
+
+DescribeScdnCertificateListResult::DescribeScdnCertificateListResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnCertificateListResult::~DescribeScdnCertificateListResult()
+{}
+
+void DescribeScdnCertificateListResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto certificateListModelNode = value["CertificateListModel"];
+	if(!certificateListModelNode["Count"].isNull())
+		certificateListModel_.count = std::stoi(certificateListModelNode["Count"].asString());
+	auto allCertList = value["CertList"]["Cert"];
+	for (auto value : allCertList)
+	{
+		CertificateListModel::Cert certObject;
+		if(!value["CertName"].isNull())
+			certObject.certName = value["CertName"].asString();
+		if(!value["CertId"].isNull())
+			certObject.certId = std::stol(value["CertId"].asString());
+		if(!value["Fingerprint"].isNull())
+			certObject.fingerprint = value["Fingerprint"].asString();
+		if(!value["Common"].isNull())
+			certObject.common = value["Common"].asString();
+		if(!value["Issuer"].isNull())
+			certObject.issuer = value["Issuer"].asString();
+		if(!value["LastTime"].isNull())
+			certObject.lastTime = std::stol(value["LastTime"].asString());
+		certificateListModel_.certList.push_back(certObject);
+	}
+
+}
+
+DescribeScdnCertificateListResult::CertificateListModel DescribeScdnCertificateListResult::getCertificateListModel()const
+{
+	return certificateListModel_;
+}
+

scdn/src/model/DescribeScdnDomainBpsDataRequest.cc

@@ -0,0 +1,324 @@
+/*
+ * 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/DescribeScdnDomainBpsDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainBpsDataRequest;
+
+DescribeScdnDomainBpsDataRequest::DescribeScdnDomainBpsDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainBpsData")
+{}
+
+DescribeScdnDomainBpsDataRequest::~DescribeScdnDomainBpsDataRequest()
+{}
+
+long DescribeScdnDomainBpsDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainBpsDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getLocationNameEn()const
+{
+	return locationNameEn_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setLocationNameEn(const std::string& locationNameEn)
+{
+	locationNameEn_ = locationNameEn;
+	setParameter("LocationNameEn", locationNameEn);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getIspNameEn()const
+{
+	return ispNameEn_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setIspNameEn(const std::string& ispNameEn)
+{
+	ispNameEn_ = ispNameEn;
+	setParameter("IspNameEn", ispNameEn);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainBpsDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainBpsDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainBpsDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainBpsDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainBpsDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string DescribeScdnDomainBpsDataRequest::getFields()const
+{
+	return fields_;
+}
+
+void DescribeScdnDomainBpsDataRequest::setFields(const std::string& fields)
+{
+	fields_ = fields;
+	setParameter("Fields", fields);
+}
+

scdn/src/model/DescribeScdnDomainBpsDataResult.cc

@@ -0,0 +1,92 @@
+/*
+ * 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/DescribeScdnDomainBpsDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainBpsDataResult::DescribeScdnDomainBpsDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainBpsDataResult::DescribeScdnDomainBpsDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainBpsDataResult::~DescribeScdnDomainBpsDataResult()
+{}
+
+void DescribeScdnDomainBpsDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allBpsDataPerInterval = value["BpsDataPerInterval"]["DataModule"];
+	for (auto value : allBpsDataPerInterval)
+	{
+		DataModule bpsDataPerIntervalObject;
+		if(!value["TimeStamp"].isNull())
+			bpsDataPerIntervalObject.timeStamp = value["TimeStamp"].asString();
+		if(!value["BpsValue"].isNull())
+			bpsDataPerIntervalObject.bpsValue = value["BpsValue"].asString();
+		if(!value["HttpBpsValue"].isNull())
+			bpsDataPerIntervalObject.httpBpsValue = value["HttpBpsValue"].asString();
+		if(!value["HttpsBpsValue"].isNull())
+			bpsDataPerIntervalObject.httpsBpsValue = value["HttpsBpsValue"].asString();
+		bpsDataPerInterval_.push_back(bpsDataPerIntervalObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+
+}
+
+std::string DescribeScdnDomainBpsDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeScdnDomainBpsDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeScdnDomainBpsDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::string DescribeScdnDomainBpsDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+
+std::vector<DescribeScdnDomainBpsDataResult::DataModule> DescribeScdnDomainBpsDataResult::getBpsDataPerInterval()const
+{
+	return bpsDataPerInterval_;
+}
+

scdn/src/model/DescribeScdnDomainCertificateInfoRequest.cc

@@ -0,0 +1,258 @@
+/*
+ * 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/DescribeScdnDomainCertificateInfoRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainCertificateInfoRequest;
+
+DescribeScdnDomainCertificateInfoRequest::DescribeScdnDomainCertificateInfoRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainCertificateInfo")
+{}
+
+DescribeScdnDomainCertificateInfoRequest::~DescribeScdnDomainCertificateInfoRequest()
+{}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+long DescribeScdnDomainCertificateInfoRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+bool DescribeScdnDomainCertificateInfoRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainCertificateInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+bool DescribeScdnDomainCertificateInfoRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainCertificateInfoRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+bool DescribeScdnDomainCertificateInfoRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainCertificateInfoRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainCertificateInfoRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainCertificateInfoRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+

scdn/src/model/DescribeScdnDomainCertificateInfoResult.cc

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

scdn/src/model/DescribeScdnDomainCnameRequest.cc

@@ -0,0 +1,258 @@
+/*
+ * 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/DescribeScdnDomainCnameRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainCnameRequest;
+
+DescribeScdnDomainCnameRequest::DescribeScdnDomainCnameRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainCname")
+{}
+
+DescribeScdnDomainCnameRequest::~DescribeScdnDomainCnameRequest()
+{}
+
+std::string DescribeScdnDomainCnameRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainCnameRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainCnameRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainCnameRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+long DescribeScdnDomainCnameRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainCnameRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+std::string DescribeScdnDomainCnameRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainCnameRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+bool DescribeScdnDomainCnameRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainCnameRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainCnameRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainCnameRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainCnameRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainCnameRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainCnameRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainCnameRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainCnameRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainCnameRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+std::string DescribeScdnDomainCnameRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainCnameRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainCnameRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainCnameRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+bool DescribeScdnDomainCnameRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainCnameRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainCnameRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainCnameRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+std::string DescribeScdnDomainCnameRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainCnameRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+bool DescribeScdnDomainCnameRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainCnameRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainCnameRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainCnameRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainCnameRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainCnameRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainCnameRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainCnameRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainCnameRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainCnameRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainCnameRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainCnameRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainCnameRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainCnameRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+

scdn/src/model/DescribeScdnDomainCnameResult.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/DescribeScdnDomainCnameResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainCnameResult::DescribeScdnDomainCnameResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainCnameResult::DescribeScdnDomainCnameResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainCnameResult::~DescribeScdnDomainCnameResult()
+{}
+
+void DescribeScdnDomainCnameResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allCnameDatas = value["CnameDatas"]["Data"];
+	for (auto value : allCnameDatas)
+	{
+		Data cnameDatasObject;
+		if(!value["Domain"].isNull())
+			cnameDatasObject.domain = value["Domain"].asString();
+		if(!value["Cname"].isNull())
+			cnameDatasObject.cname = value["Cname"].asString();
+		if(!value["Status"].isNull())
+			cnameDatasObject.status = std::stoi(value["Status"].asString());
+		cnameDatas_.push_back(cnameDatasObject);
+	}
+
+}
+
+std::vector<DescribeScdnDomainCnameResult::Data> DescribeScdnDomainCnameResult::getCnameDatas()const
+{
+	return cnameDatas_;
+}
+

scdn/src/model/DescribeScdnDomainConfigsRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * 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/DescribeScdnDomainConfigsRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainConfigsRequest;
+
+DescribeScdnDomainConfigsRequest::DescribeScdnDomainConfigsRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainConfigs")
+{}
+
+DescribeScdnDomainConfigsRequest::~DescribeScdnDomainConfigsRequest()
+{}
+
+std::string DescribeScdnDomainConfigsRequest::getFunctionNames()const
+{
+	return functionNames_;
+}
+
+void DescribeScdnDomainConfigsRequest::setFunctionNames(const std::string& functionNames)
+{
+	functionNames_ = functionNames;
+	setParameter("FunctionNames", functionNames);
+}
+
+std::string DescribeScdnDomainConfigsRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainConfigsRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainConfigsRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainConfigsRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+long DescribeScdnDomainConfigsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainConfigsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainConfigsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainConfigsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+

scdn/src/model/DescribeScdnDomainConfigsResult.cc

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

scdn/src/model/DescribeScdnDomainDetailRequest.cc

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

scdn/src/model/DescribeScdnDomainDetailResult.cc

@@ -0,0 +1,89 @@
+/*
+ * 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/DescribeScdnDomainDetailResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainDetailResult::DescribeScdnDomainDetailResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainDetailResult::DescribeScdnDomainDetailResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainDetailResult::~DescribeScdnDomainDetailResult()
+{}
+
+void DescribeScdnDomainDetailResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto domainDetailNode = value["DomainDetail"];
+	if(!domainDetailNode["GmtCreated"].isNull())
+		domainDetail_.gmtCreated = domainDetailNode["GmtCreated"].asString();
+	if(!domainDetailNode["GmtModified"].isNull())
+		domainDetail_.gmtModified = domainDetailNode["GmtModified"].asString();
+	if(!domainDetailNode["DomainStatus"].isNull())
+		domainDetail_.domainStatus = domainDetailNode["DomainStatus"].asString();
+	if(!domainDetailNode["Cname"].isNull())
+		domainDetail_.cname = domainDetailNode["Cname"].asString();
+	if(!domainDetailNode["DomainName"].isNull())
+		domainDetail_.domainName = domainDetailNode["DomainName"].asString();
+	if(!domainDetailNode["Description"].isNull())
+		domainDetail_.description = domainDetailNode["Description"].asString();
+	if(!domainDetailNode["SSLProtocol"].isNull())
+		domainDetail_.sSLProtocol = domainDetailNode["SSLProtocol"].asString();
+	if(!domainDetailNode["SSLPub"].isNull())
+		domainDetail_.sSLPub = domainDetailNode["SSLPub"].asString();
+	if(!domainDetailNode["Scope"].isNull())
+		domainDetail_.scope = domainDetailNode["Scope"].asString();
+	if(!domainDetailNode["CertName"].isNull())
+		domainDetail_.certName = domainDetailNode["CertName"].asString();
+	if(!domainDetailNode["ResourceGroupId"].isNull())
+		domainDetail_.resourceGroupId = domainDetailNode["ResourceGroupId"].asString();
+	auto allSources = value["Sources"]["Source"];
+	for (auto value : allSources)
+	{
+		DomainDetail::Source sourceObject;
+		if(!value["Content"].isNull())
+			sourceObject.content = value["Content"].asString();
+		if(!value["Type"].isNull())
+			sourceObject.type = value["Type"].asString();
+		if(!value["Port"].isNull())
+			sourceObject.port = std::stoi(value["Port"].asString());
+		if(!value["Enabled"].isNull())
+			sourceObject.enabled = value["Enabled"].asString();
+		if(!value["Priority"].isNull())
+			sourceObject.priority = value["Priority"].asString();
+		domainDetail_.sources.push_back(sourceObject);
+	}
+
+}
+
+DescribeScdnDomainDetailResult::DomainDetail DescribeScdnDomainDetailResult::getDomainDetail()const
+{
+	return domainDetail_;
+}
+

scdn/src/model/DescribeScdnDomainHitRateDataRequest.cc

@@ -0,0 +1,302 @@
+/*
+ * 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/DescribeScdnDomainHitRateDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainHitRateDataRequest;
+
+DescribeScdnDomainHitRateDataRequest::DescribeScdnDomainHitRateDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainHitRateData")
+{}
+
+DescribeScdnDomainHitRateDataRequest::~DescribeScdnDomainHitRateDataRequest()
+{}
+
+long DescribeScdnDomainHitRateDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainHitRateDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainHitRateDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainHitRateDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainHitRateDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainHitRateDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainHitRateDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string DescribeScdnDomainHitRateDataRequest::getFields()const
+{
+	return fields_;
+}
+
+void DescribeScdnDomainHitRateDataRequest::setFields(const std::string& fields)
+{
+	fields_ = fields;
+	setParameter("Fields", fields);
+}
+

scdn/src/model/DescribeScdnDomainHitRateDataResult.cc

@@ -0,0 +1,90 @@
+/*
+ * 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/DescribeScdnDomainHitRateDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainHitRateDataResult::DescribeScdnDomainHitRateDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainHitRateDataResult::DescribeScdnDomainHitRateDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainHitRateDataResult::~DescribeScdnDomainHitRateDataResult()
+{}
+
+void DescribeScdnDomainHitRateDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allHitRatePerInterval = value["HitRatePerInterval"]["DataModule"];
+	for (auto value : allHitRatePerInterval)
+	{
+		DataModule hitRatePerIntervalObject;
+		if(!value["TimeStamp"].isNull())
+			hitRatePerIntervalObject.timeStamp = value["TimeStamp"].asString();
+		if(!value["ReqHitRate"].isNull())
+			hitRatePerIntervalObject.reqHitRate = value["ReqHitRate"].asString();
+		if(!value["ByteHitRate"].isNull())
+			hitRatePerIntervalObject.byteHitRate = value["ByteHitRate"].asString();
+		hitRatePerInterval_.push_back(hitRatePerIntervalObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+
+}
+
+std::string DescribeScdnDomainHitRateDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeScdnDomainHitRateDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::vector<DescribeScdnDomainHitRateDataResult::DataModule> DescribeScdnDomainHitRateDataResult::getHitRatePerInterval()const
+{
+	return hitRatePerInterval_;
+}
+
+std::string DescribeScdnDomainHitRateDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::string DescribeScdnDomainHitRateDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+

scdn/src/model/DescribeScdnDomainHttpCodeDataRequest.cc

@@ -0,0 +1,324 @@
+/*
+ * 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/DescribeScdnDomainHttpCodeDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainHttpCodeDataRequest;
+
+DescribeScdnDomainHttpCodeDataRequest::DescribeScdnDomainHttpCodeDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainHttpCodeData")
+{}
+
+DescribeScdnDomainHttpCodeDataRequest::~DescribeScdnDomainHttpCodeDataRequest()
+{}
+
+long DescribeScdnDomainHttpCodeDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainHttpCodeDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getLocationNameEn()const
+{
+	return locationNameEn_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setLocationNameEn(const std::string& locationNameEn)
+{
+	locationNameEn_ = locationNameEn;
+	setParameter("LocationNameEn", locationNameEn);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getIspNameEn()const
+{
+	return ispNameEn_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setIspNameEn(const std::string& ispNameEn)
+{
+	ispNameEn_ = ispNameEn;
+	setParameter("IspNameEn", ispNameEn);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainHttpCodeDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainHttpCodeDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainHttpCodeDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainHttpCodeDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainHttpCodeDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string DescribeScdnDomainHttpCodeDataRequest::getFields()const
+{
+	return fields_;
+}
+
+void DescribeScdnDomainHttpCodeDataRequest::setFields(const std::string& fields)
+{
+	fields_ = fields;
+	setParameter("Fields", fields);
+}
+

scdn/src/model/DescribeScdnDomainHttpCodeDataResult.cc

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

scdn/src/model/DescribeScdnDomainLogRequest.cc

@@ -0,0 +1,302 @@
+/*
+ * 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/DescribeScdnDomainLogRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainLogRequest;
+
+DescribeScdnDomainLogRequest::DescribeScdnDomainLogRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainLog")
+{}
+
+DescribeScdnDomainLogRequest::~DescribeScdnDomainLogRequest()
+{}
+
+long DescribeScdnDomainLogRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainLogRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainLogRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainLogRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainLogRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainLogRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainLogRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainLogRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainLogRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainLogRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainLogRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainLogRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+long DescribeScdnDomainLogRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeScdnDomainLogRequest::setPageNumber(long pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeScdnDomainLogRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainLogRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainLogRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainLogRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainLogRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainLogRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+long DescribeScdnDomainLogRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeScdnDomainLogRequest::setPageSize(long pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeScdnDomainLogRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainLogRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainLogRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainLogRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainLogRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainLogRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainLogRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainLogRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainLogRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainLogRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainLogRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainLogRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainLogRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainLogRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainLogRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainLogRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainLogRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainLogRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainLogRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainLogRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainLogRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainLogRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainLogRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainLogRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainLogRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainLogRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainLogRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainLogRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+

scdn/src/model/DescribeScdnDomainLogResult.cc

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/scdn/model/DescribeScdnDomainLogResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainLogResult::DescribeScdnDomainLogResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainLogResult::DescribeScdnDomainLogResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainLogResult::~DescribeScdnDomainLogResult()
+{}
+
+void DescribeScdnDomainLogResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allDomainLogDetails = value["DomainLogDetails"]["DomainLogDetail"];
+	for (auto value : allDomainLogDetails)
+	{
+		DomainLogDetail domainLogDetailsObject;
+		if(!value["LogCount"].isNull())
+			domainLogDetailsObject.logCount = std::stol(value["LogCount"].asString());
+		auto allPageInfos = value["PageInfos"]["PageInfoDetail"];
+		for (auto value : allPageInfos)
+		{
+			DomainLogDetail::PageInfoDetail pageInfosObject;
+			if(!value["PageIndex"].isNull())
+				pageInfosObject.pageIndex = std::stol(value["PageIndex"].asString());
+			if(!value["PageSize"].isNull())
+				pageInfosObject.pageSize = std::stol(value["PageSize"].asString());
+			if(!value["Total"].isNull())
+				pageInfosObject.total = std::stol(value["Total"].asString());
+			domainLogDetailsObject.pageInfos.push_back(pageInfosObject);
+		}
+		auto allLogInfos = value["LogInfos"]["LogInfoDetail"];
+		for (auto value : allLogInfos)
+		{
+			DomainLogDetail::LogInfoDetail logInfosObject;
+			if(!value["LogName"].isNull())
+				logInfosObject.logName = value["LogName"].asString();
+			if(!value["LogPath"].isNull())
+				logInfosObject.logPath = value["LogPath"].asString();
+			if(!value["LogSize"].isNull())
+				logInfosObject.logSize = std::stol(value["LogSize"].asString());
+			if(!value["StartTime"].isNull())
+				logInfosObject.startTime = value["StartTime"].asString();
+			if(!value["EndTime"].isNull())
+				logInfosObject.endTime = value["EndTime"].asString();
+			domainLogDetailsObject.logInfos.push_back(logInfosObject);
+		}
+		domainLogDetails_.push_back(domainLogDetailsObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+
+}
+
+std::string DescribeScdnDomainLogResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::vector<DescribeScdnDomainLogResult::DomainLogDetail> DescribeScdnDomainLogResult::getDomainLogDetails()const
+{
+	return domainLogDetails_;
+}
+

scdn/src/model/DescribeScdnDomainOriginBpsDataRequest.cc

@@ -0,0 +1,302 @@
+/*
+ * 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/DescribeScdnDomainOriginBpsDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainOriginBpsDataRequest;
+
+DescribeScdnDomainOriginBpsDataRequest::DescribeScdnDomainOriginBpsDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainOriginBpsData")
+{}
+
+DescribeScdnDomainOriginBpsDataRequest::~DescribeScdnDomainOriginBpsDataRequest()
+{}
+
+long DescribeScdnDomainOriginBpsDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainOriginBpsDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainOriginBpsDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainOriginBpsDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainOriginBpsDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainOriginBpsDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainOriginBpsDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string DescribeScdnDomainOriginBpsDataRequest::getFields()const
+{
+	return fields_;
+}
+
+void DescribeScdnDomainOriginBpsDataRequest::setFields(const std::string& fields)
+{
+	fields_ = fields;
+	setParameter("Fields", fields);
+}
+

scdn/src/model/DescribeScdnDomainOriginBpsDataResult.cc

@@ -0,0 +1,92 @@
+/*
+ * 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/DescribeScdnDomainOriginBpsDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainOriginBpsDataResult::DescribeScdnDomainOriginBpsDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainOriginBpsDataResult::DescribeScdnDomainOriginBpsDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainOriginBpsDataResult::~DescribeScdnDomainOriginBpsDataResult()
+{}
+
+void DescribeScdnDomainOriginBpsDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allOriginBpsDataPerInterval = value["OriginBpsDataPerInterval"]["DataModule"];
+	for (auto value : allOriginBpsDataPerInterval)
+	{
+		DataModule originBpsDataPerIntervalObject;
+		if(!value["TimeStamp"].isNull())
+			originBpsDataPerIntervalObject.timeStamp = value["TimeStamp"].asString();
+		if(!value["OriginBpsValue"].isNull())
+			originBpsDataPerIntervalObject.originBpsValue = value["OriginBpsValue"].asString();
+		if(!value["HttpOriginBpsValue"].isNull())
+			originBpsDataPerIntervalObject.httpOriginBpsValue = value["HttpOriginBpsValue"].asString();
+		if(!value["HttpsOriginBpsValue"].isNull())
+			originBpsDataPerIntervalObject.httpsOriginBpsValue = value["HttpsOriginBpsValue"].asString();
+		originBpsDataPerInterval_.push_back(originBpsDataPerIntervalObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+
+}
+
+std::string DescribeScdnDomainOriginBpsDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeScdnDomainOriginBpsDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeScdnDomainOriginBpsDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::string DescribeScdnDomainOriginBpsDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+
+std::vector<DescribeScdnDomainOriginBpsDataResult::DataModule> DescribeScdnDomainOriginBpsDataResult::getOriginBpsDataPerInterval()const
+{
+	return originBpsDataPerInterval_;
+}
+

scdn/src/model/DescribeScdnDomainOriginTrafficDataRequest.cc

@@ -0,0 +1,302 @@
+/*
+ * 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/DescribeScdnDomainOriginTrafficDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainOriginTrafficDataRequest;
+
+DescribeScdnDomainOriginTrafficDataRequest::DescribeScdnDomainOriginTrafficDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainOriginTrafficData")
+{}
+
+DescribeScdnDomainOriginTrafficDataRequest::~DescribeScdnDomainOriginTrafficDataRequest()
+{}
+
+long DescribeScdnDomainOriginTrafficDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainOriginTrafficDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainOriginTrafficDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainOriginTrafficDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainOriginTrafficDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainOriginTrafficDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainOriginTrafficDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string DescribeScdnDomainOriginTrafficDataRequest::getFields()const
+{
+	return fields_;
+}
+
+void DescribeScdnDomainOriginTrafficDataRequest::setFields(const std::string& fields)
+{
+	fields_ = fields;
+	setParameter("Fields", fields);
+}
+

scdn/src/model/DescribeScdnDomainOriginTrafficDataResult.cc

@@ -0,0 +1,92 @@
+/*
+ * 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/DescribeScdnDomainOriginTrafficDataResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Scdn;
+using namespace AlibabaCloud::Scdn::Model;
+
+DescribeScdnDomainOriginTrafficDataResult::DescribeScdnDomainOriginTrafficDataResult() :
+	ServiceResult()
+{}
+
+DescribeScdnDomainOriginTrafficDataResult::DescribeScdnDomainOriginTrafficDataResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeScdnDomainOriginTrafficDataResult::~DescribeScdnDomainOriginTrafficDataResult()
+{}
+
+void DescribeScdnDomainOriginTrafficDataResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+
+	setRequestId(value["RequestId"].asString());
+	auto allOriginTrafficDataPerInterval = value["OriginTrafficDataPerInterval"]["DataModule"];
+	for (auto value : allOriginTrafficDataPerInterval)
+	{
+		DataModule originTrafficDataPerIntervalObject;
+		if(!value["TimeStamp"].isNull())
+			originTrafficDataPerIntervalObject.timeStamp = value["TimeStamp"].asString();
+		if(!value["TrafficValue"].isNull())
+			originTrafficDataPerIntervalObject.trafficValue = value["TrafficValue"].asString();
+		if(!value["HttpTrafficValue"].isNull())
+			originTrafficDataPerIntervalObject.httpTrafficValue = value["HttpTrafficValue"].asString();
+		if(!value["HttpsTrafficValue"].isNull())
+			originTrafficDataPerIntervalObject.httpsTrafficValue = value["HttpsTrafficValue"].asString();
+		originTrafficDataPerInterval_.push_back(originTrafficDataPerIntervalObject);
+	}
+	if(!value["DomainName"].isNull())
+		domainName_ = value["DomainName"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["DataInterval"].isNull())
+		dataInterval_ = value["DataInterval"].asString();
+
+}
+
+std::string DescribeScdnDomainOriginTrafficDataResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribeScdnDomainOriginTrafficDataResult::getDomainName()const
+{
+	return domainName_;
+}
+
+std::string DescribeScdnDomainOriginTrafficDataResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::string DescribeScdnDomainOriginTrafficDataResult::getDataInterval()const
+{
+	return dataInterval_;
+}
+
+std::vector<DescribeScdnDomainOriginTrafficDataResult::DataModule> DescribeScdnDomainOriginTrafficDataResult::getOriginTrafficDataPerInterval()const
+{
+	return originTrafficDataPerInterval_;
+}
+

scdn/src/model/DescribeScdnDomainQpsDataRequest.cc

@@ -0,0 +1,324 @@
+/*
+ * 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/DescribeScdnDomainQpsDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainQpsDataRequest;
+
+DescribeScdnDomainQpsDataRequest::DescribeScdnDomainQpsDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainQpsData")
+{}
+
+DescribeScdnDomainQpsDataRequest::~DescribeScdnDomainQpsDataRequest()
+{}
+
+long DescribeScdnDomainQpsDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainQpsDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getLocationNameEn()const
+{
+	return locationNameEn_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setLocationNameEn(const std::string& locationNameEn)
+{
+	locationNameEn_ = locationNameEn;
+	setParameter("LocationNameEn", locationNameEn);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getIspNameEn()const
+{
+	return ispNameEn_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setIspNameEn(const std::string& ispNameEn)
+{
+	ispNameEn_ = ispNameEn;
+	setParameter("IspNameEn", ispNameEn);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainQpsDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainQpsDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainQpsDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainQpsDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainQpsDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string DescribeScdnDomainQpsDataRequest::getFields()const
+{
+	return fields_;
+}
+
+void DescribeScdnDomainQpsDataRequest::setFields(const std::string& fields)
+{
+	fields_ = fields;
+	setParameter("Fields", fields);
+}
+

scdn/src/model/DescribeScdnDomainQpsDataResult.cc

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

scdn/src/model/DescribeScdnDomainTrafficDataRequest.cc

@@ -0,0 +1,324 @@
+/*
+ * 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/DescribeScdnDomainTrafficDataRequest.h>
+
+using AlibabaCloud::Scdn::Model::DescribeScdnDomainTrafficDataRequest;
+
+DescribeScdnDomainTrafficDataRequest::DescribeScdnDomainTrafficDataRequest() :
+	RpcServiceRequest("scdn", "2017-11-15", "DescribeScdnDomainTrafficData")
+{}
+
+DescribeScdnDomainTrafficDataRequest::~DescribeScdnDomainTrafficDataRequest()
+{}
+
+long DescribeScdnDomainTrafficDataRequest::getCallerParentId()const
+{
+	return callerParentId_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setCallerParentId(long callerParentId)
+{
+	callerParentId_ = callerParentId;
+	setParameter("CallerParentId", std::to_string(callerParentId));
+}
+
+bool DescribeScdnDomainTrafficDataRequest::getProxy_original_security_transport()const
+{
+	return proxy_original_security_transport_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setProxy_original_security_transport(bool proxy_original_security_transport)
+{
+	proxy_original_security_transport_ = proxy_original_security_transport;
+	setParameter("Proxy_original_security_transport", std::to_string(proxy_original_security_transport));
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getLocationNameEn()const
+{
+	return locationNameEn_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setLocationNameEn(const std::string& locationNameEn)
+{
+	locationNameEn_ = locationNameEn;
+	setParameter("LocationNameEn", locationNameEn);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getIspNameEn()const
+{
+	return ispNameEn_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setIspNameEn(const std::string& ispNameEn)
+{
+	ispNameEn_ = ispNameEn;
+	setParameter("IspNameEn", ispNameEn);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getProxy_original_source_ip()const
+{
+	return proxy_original_source_ip_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setProxy_original_source_ip(const std::string& proxy_original_source_ip)
+{
+	proxy_original_source_ip_ = proxy_original_source_ip;
+	setParameter("Proxy_original_source_ip", proxy_original_source_ip);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getOwnerIdLoginEmail()const
+{
+	return ownerIdLoginEmail_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setOwnerIdLoginEmail(const std::string& ownerIdLoginEmail)
+{
+	ownerIdLoginEmail_ = ownerIdLoginEmail;
+	setParameter("OwnerIdLoginEmail", ownerIdLoginEmail);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getCallerType()const
+{
+	return callerType_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setCallerType(const std::string& callerType)
+{
+	callerType_ = callerType;
+	setParameter("CallerType", callerType);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getSecurityToken()const
+{
+	return securityToken_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setSecurityToken(const std::string& securityToken)
+{
+	securityToken_ = securityToken;
+	setParameter("SecurityToken", securityToken);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getRequestContent()const
+{
+	return requestContent_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setRequestContent(const std::string& requestContent)
+{
+	requestContent_ = requestContent;
+	setParameter("RequestContent", requestContent);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getCallerBidEmail()const
+{
+	return callerBidEmail_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setCallerBidEmail(const std::string& callerBidEmail)
+{
+	callerBidEmail_ = callerBidEmail;
+	setParameter("CallerBidEmail", callerBidEmail);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getCallerUidEmail()const
+{
+	return callerUidEmail_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setCallerUidEmail(const std::string& callerUidEmail)
+{
+	callerUidEmail_ = callerUidEmail;
+	setParameter("CallerUidEmail", callerUidEmail);
+}
+
+long DescribeScdnDomainTrafficDataRequest::getCallerUid()const
+{
+	return callerUid_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setCallerUid(long callerUid)
+{
+	callerUid_ = callerUid;
+	setParameter("CallerUid", std::to_string(callerUid));
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getApp_ip()const
+{
+	return app_ip_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setApp_ip(const std::string& app_ip)
+{
+	app_ip_ = app_ip;
+	setParameter("App_ip", app_ip);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getProduct()const
+{
+	return product_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setProduct(const std::string& product)
+{
+	product_ = product;
+	setParameter("Product", product);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getDomainName()const
+{
+	return domainName_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setDomainName(const std::string& domainName)
+{
+	domainName_ = domainName;
+	setParameter("DomainName", domainName);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getCallerBid()const
+{
+	return callerBid_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setCallerBid(const std::string& callerBid)
+{
+	callerBid_ = callerBid;
+	setParameter("CallerBid", callerBid);
+}
+
+long DescribeScdnDomainTrafficDataRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getVersion()const
+{
+	return version_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setVersion(const std::string& version)
+{
+	version_ = version;
+	setParameter("Version", version);
+}
+
+bool DescribeScdnDomainTrafficDataRequest::getProxy_trust_transport_info()const
+{
+	return proxy_trust_transport_info_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setProxy_trust_transport_info(bool proxy_trust_transport_info)
+{
+	proxy_trust_transport_info_ = proxy_trust_transport_info;
+	setParameter("Proxy_trust_transport_info", std::to_string(proxy_trust_transport_info));
+}
+
+bool DescribeScdnDomainTrafficDataRequest::getAk_mfa_present()const
+{
+	return ak_mfa_present_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setAk_mfa_present(bool ak_mfa_present)
+{
+	ak_mfa_present_ = ak_mfa_present;
+	setParameter("Ak_mfa_present", std::to_string(ak_mfa_present));
+}
+
+bool DescribeScdnDomainTrafficDataRequest::getSecurity_transport()const
+{
+	return security_transport_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setSecurity_transport(bool security_transport)
+{
+	security_transport_ = security_transport;
+	setParameter("Security_transport", std::to_string(security_transport));
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getRequestId()const
+{
+	return requestId_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setRequestId(const std::string& requestId)
+{
+	requestId_ = requestId;
+	setParameter("RequestId", requestId);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getInterval()const
+{
+	return interval_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+
+std::string DescribeScdnDomainTrafficDataRequest::getFields()const
+{
+	return fields_;
+}
+
+void DescribeScdnDomainTrafficDataRequest::setFields(const std::string& fields)
+{
+	fields_ = fields;
+	setParameter("Fields", fields);
+}
+