Create Lindorm Open api.

CHANGELOG

@@ -1,3 +1,108 @@
+2021-05-28 Version: 1.36.759
+- Create Lindorm Open api.
+
+2021-05-28 Version: 1.36.758
+- Create Lindorm Open api.
+
+2021-05-27 Version: 1.36.757
+- Generated 2019-09-10 for `waf-openapi`.
+
+2021-05-25 Version: 1.36.756
+- Export new API for IVR tracking.
+
+2021-05-24 Version: 1.36.755
+- Support a2a openapi.
+
+2021-05-24 Version: 1.36.754
+- Export new API for report.
+
+2021-05-24 Version: 1.36.753
+- Support TransformDBClusterPayType.
+
+2021-05-23 Version: 1.36.752
+- New API- GetDrdsDbRdsRelationInfo, which can get private RDS list under certain DB out of DRDS instance ID and DB name.
+
+2021-05-22 Version: 1.36.751
+- Aaaaa.
+
+2021-05-21 Version: 1.36.750
+- Supported DescribeLoadBalancers with DeleteProtection and so on.
+
+2021-05-21 Version: 1.36.749
+- Support StrictResourceProvision in ApplyNodes.
+
+2021-05-20 Version: 1.36.748
+- Upgrade mongodb sdk.
+
+2021-05-20 Version: 1.36.747
+- DescribeAvailableResource frequency.
+
+2021-05-19 Version: 1.36.746
+- Generated 2020-05-18 for `dataworks-public`.
+
+2021-05-19 Version: 1.36.745
+- Update API.
+
+2021-05-19 Version: 1.36.744
+- Publish multi language sdk.
+
+2021-05-18 Version: 1.36.743
+- Add IoT Studio SetStudioProjectCooperation API.
+- Add IoT Studio QueryStudioProjectList API.
+- Add IoT Studio QueryStudioAppList API.
+- Add IoT Studio QueryStudioAppPageListOpen API.
+- Add IoT Studio QueryStudioAppDomainListOpen API.
+- Add IoT Studio DeleteStudioAppDomainOpen API.
+- Add IoT Studio CreateStudioAppDomainOpen API.
+- Add IoT Studio GetStudioAppTokenOpen API.
+- Add IoT Studio SetupStudioAppAuthModeOpen API.
+- Add IoT Studio RefreshStudioAppTokenOpen API.
+- Add IoT Studio PublishStudioApp API.
+
+2021-05-18 Version: 1.36.742
+- Support MinCount for AddNodes.
+- Support HostNamePreffix and HostNameSuffix for ListNodes.
+
+2021-05-17 Version: 1.36.741
+- Add API ListQuotaReviewTasks.
+
+2021-05-17 Version: 1.36.740
+- Support DescribeInstallCaptcha API.
+
+2021-05-17 Version: 1.36.739
+- Export new API for predictive dialer.
+
+2021-05-17 Version: 1.36.738
+- Add DescribeDcdnRefreshTaskById.
+
+2021-05-14 Version: 1.36.737
+- Release ExtractFingerPrint.
+
+2021-05-14 Version: 1.36.736
+- EnableAdditionalBandwidth add AutoRenew,AutoRenewPeriod parameter.
+
+2021-05-14 Version: 1.36.735
+- Update ScreenChestCT.
+
+2021-05-14 Version: 1.36.734
+- Support Private RDS management through OpenAPI.
+- ManagePrivateRds to do RDS information query and some management.
+- DescribeDrdsRdsInstances to find RDS under a certain DRDS instance.
+- UpdatePrivateRdsClass to Upgrade or Downgrade your Private RDS class.
+
+2021-05-14 Version: 1.36.733
+- Support Private RDS management through OpenAPI.
+- ManagePrivateRds to do RDS information query and some management.
+- DescribeDrdsRdsInstances to find RDS under a certain DRDS instance.
+- UpdatePrivateRdsClass to Upgrade or Downgrade your Private RDS class.
+
+2021-05-13 Version: 1.36.732
+- Support query quota.
+- Supprt create quota increase request.
+
+2021-05-13 Version: 1.36.731
+- Generated 2020-01-01 for `ddoscoo`.
+
 2021-05-13 Version: 1.36.730
 - Add Indexing-Service support.
 - Remove jsonItem form.

VERSION

@@ -1 +1 @@
-1.36.730
+1.36.759

address-purification/CMakeLists.txt

@@ -29,18 +29,34 @@ set(address-purification_public_header_model
 	include/alibabacloud/address-purification/model/CorrectAddressResult.h
 	include/alibabacloud/address-purification/model/ExtractAddressRequest.h
 	include/alibabacloud/address-purification/model/ExtractAddressResult.h
+	include/alibabacloud/address-purification/model/ExtractExpressRequest.h
+	include/alibabacloud/address-purification/model/ExtractExpressResult.h
 	include/alibabacloud/address-purification/model/ExtractNameRequest.h
 	include/alibabacloud/address-purification/model/ExtractNameResult.h
 	include/alibabacloud/address-purification/model/ExtractPhoneRequest.h
 	include/alibabacloud/address-purification/model/ExtractPhoneResult.h
+	include/alibabacloud/address-purification/model/GetAddressBlockMappingRequest.h
+	include/alibabacloud/address-purification/model/GetAddressBlockMappingResult.h
 	include/alibabacloud/address-purification/model/GetAddressDivisionCodeRequest.h
 	include/alibabacloud/address-purification/model/GetAddressDivisionCodeResult.h
+	include/alibabacloud/address-purification/model/GetAddressEvaluateRequest.h
+	include/alibabacloud/address-purification/model/GetAddressEvaluateResult.h
+	include/alibabacloud/address-purification/model/GetAddressGeocodeRequest.h
+	include/alibabacloud/address-purification/model/GetAddressGeocodeResult.h
+	include/alibabacloud/address-purification/model/GetAddressSearchRequest.h
+	include/alibabacloud/address-purification/model/GetAddressSearchResult.h
 	include/alibabacloud/address-purification/model/GetAddressSimilarityRequest.h
 	include/alibabacloud/address-purification/model/GetAddressSimilarityResult.h
+	include/alibabacloud/address-purification/model/GetInputSearchRequest.h
+	include/alibabacloud/address-purification/model/GetInputSearchResult.h
 	include/alibabacloud/address-purification/model/GetZipcodeRequest.h
 	include/alibabacloud/address-purification/model/GetZipcodeResult.h
+	include/alibabacloud/address-purification/model/PredictPOIRequest.h
+	include/alibabacloud/address-purification/model/PredictPOIResult.h
 	include/alibabacloud/address-purification/model/StructureAddressRequest.h
 	include/alibabacloud/address-purification/model/StructureAddressResult.h
+	include/alibabacloud/address-purification/model/TransferCoordRequest.h
+	include/alibabacloud/address-purification/model/TransferCoordResult.h
 	include/alibabacloud/address-purification/model/UpdateProjectRequest.h
 	include/alibabacloud/address-purification/model/UpdateProjectResult.h )
 
@@ -54,18 +70,34 @@ set(address-purification_src
 	src/model/CorrectAddressResult.cc
 	src/model/ExtractAddressRequest.cc
 	src/model/ExtractAddressResult.cc
+	src/model/ExtractExpressRequest.cc
+	src/model/ExtractExpressResult.cc
 	src/model/ExtractNameRequest.cc
 	src/model/ExtractNameResult.cc
 	src/model/ExtractPhoneRequest.cc
 	src/model/ExtractPhoneResult.cc
+	src/model/GetAddressBlockMappingRequest.cc
+	src/model/GetAddressBlockMappingResult.cc
 	src/model/GetAddressDivisionCodeRequest.cc
 	src/model/GetAddressDivisionCodeResult.cc
+	src/model/GetAddressEvaluateRequest.cc
+	src/model/GetAddressEvaluateResult.cc
+	src/model/GetAddressGeocodeRequest.cc
+	src/model/GetAddressGeocodeResult.cc
+	src/model/GetAddressSearchRequest.cc
+	src/model/GetAddressSearchResult.cc
 	src/model/GetAddressSimilarityRequest.cc
 	src/model/GetAddressSimilarityResult.cc
+	src/model/GetInputSearchRequest.cc
+	src/model/GetInputSearchResult.cc
 	src/model/GetZipcodeRequest.cc
 	src/model/GetZipcodeResult.cc
+	src/model/PredictPOIRequest.cc
+	src/model/PredictPOIResult.cc
 	src/model/StructureAddressRequest.cc
 	src/model/StructureAddressResult.cc
+	src/model/TransferCoordRequest.cc
+	src/model/TransferCoordResult.cc
 	src/model/UpdateProjectRequest.cc
 	src/model/UpdateProjectResult.cc )
 

address-purification/include/alibabacloud/address-purification/Address_purificationClient.h

@@ -30,18 +30,34 @@
 #include "model/CorrectAddressResult.h"
 #include "model/ExtractAddressRequest.h"
 #include "model/ExtractAddressResult.h"
+#include "model/ExtractExpressRequest.h"
+#include "model/ExtractExpressResult.h"
 #include "model/ExtractNameRequest.h"
 #include "model/ExtractNameResult.h"
 #include "model/ExtractPhoneRequest.h"
 #include "model/ExtractPhoneResult.h"
+#include "model/GetAddressBlockMappingRequest.h"
+#include "model/GetAddressBlockMappingResult.h"
 #include "model/GetAddressDivisionCodeRequest.h"
 #include "model/GetAddressDivisionCodeResult.h"
+#include "model/GetAddressEvaluateRequest.h"
+#include "model/GetAddressEvaluateResult.h"
+#include "model/GetAddressGeocodeRequest.h"
+#include "model/GetAddressGeocodeResult.h"
+#include "model/GetAddressSearchRequest.h"
+#include "model/GetAddressSearchResult.h"
 #include "model/GetAddressSimilarityRequest.h"
 #include "model/GetAddressSimilarityResult.h"
+#include "model/GetInputSearchRequest.h"
+#include "model/GetInputSearchResult.h"
 #include "model/GetZipcodeRequest.h"
 #include "model/GetZipcodeResult.h"
+#include "model/PredictPOIRequest.h"
+#include "model/PredictPOIResult.h"
 #include "model/StructureAddressRequest.h"
 #include "model/StructureAddressResult.h"
+#include "model/TransferCoordRequest.h"
+#include "model/TransferCoordResult.h"
 #include "model/UpdateProjectRequest.h"
 #include "model/UpdateProjectResult.h"
 
@@ -65,24 +81,48 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ExtractAddressResult> ExtractAddressOutcome;
 			typedef std::future<ExtractAddressOutcome> ExtractAddressOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::ExtractAddressRequest&, const ExtractAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractAddressAsyncHandler;
+			typedef Outcome<Error, Model::ExtractExpressResult> ExtractExpressOutcome;
+			typedef std::future<ExtractExpressOutcome> ExtractExpressOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::ExtractExpressRequest&, const ExtractExpressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractExpressAsyncHandler;
 			typedef Outcome<Error, Model::ExtractNameResult> ExtractNameOutcome;
 			typedef std::future<ExtractNameOutcome> ExtractNameOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::ExtractNameRequest&, const ExtractNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractNameAsyncHandler;
 			typedef Outcome<Error, Model::ExtractPhoneResult> ExtractPhoneOutcome;
 			typedef std::future<ExtractPhoneOutcome> ExtractPhoneOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::ExtractPhoneRequest&, const ExtractPhoneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExtractPhoneAsyncHandler;
+			typedef Outcome<Error, Model::GetAddressBlockMappingResult> GetAddressBlockMappingOutcome;
+			typedef std::future<GetAddressBlockMappingOutcome> GetAddressBlockMappingOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressBlockMappingRequest&, const GetAddressBlockMappingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressBlockMappingAsyncHandler;
 			typedef Outcome<Error, Model::GetAddressDivisionCodeResult> GetAddressDivisionCodeOutcome;
 			typedef std::future<GetAddressDivisionCodeOutcome> GetAddressDivisionCodeOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressDivisionCodeRequest&, const GetAddressDivisionCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressDivisionCodeAsyncHandler;
+			typedef Outcome<Error, Model::GetAddressEvaluateResult> GetAddressEvaluateOutcome;
+			typedef std::future<GetAddressEvaluateOutcome> GetAddressEvaluateOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressEvaluateRequest&, const GetAddressEvaluateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressEvaluateAsyncHandler;
+			typedef Outcome<Error, Model::GetAddressGeocodeResult> GetAddressGeocodeOutcome;
+			typedef std::future<GetAddressGeocodeOutcome> GetAddressGeocodeOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressGeocodeRequest&, const GetAddressGeocodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressGeocodeAsyncHandler;
+			typedef Outcome<Error, Model::GetAddressSearchResult> GetAddressSearchOutcome;
+			typedef std::future<GetAddressSearchOutcome> GetAddressSearchOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressSearchRequest&, const GetAddressSearchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressSearchAsyncHandler;
 			typedef Outcome<Error, Model::GetAddressSimilarityResult> GetAddressSimilarityOutcome;
 			typedef std::future<GetAddressSimilarityOutcome> GetAddressSimilarityOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::GetAddressSimilarityRequest&, const GetAddressSimilarityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAddressSimilarityAsyncHandler;
+			typedef Outcome<Error, Model::GetInputSearchResult> GetInputSearchOutcome;
+			typedef std::future<GetInputSearchOutcome> GetInputSearchOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::GetInputSearchRequest&, const GetInputSearchOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInputSearchAsyncHandler;
 			typedef Outcome<Error, Model::GetZipcodeResult> GetZipcodeOutcome;
 			typedef std::future<GetZipcodeOutcome> GetZipcodeOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::GetZipcodeRequest&, const GetZipcodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetZipcodeAsyncHandler;
+			typedef Outcome<Error, Model::PredictPOIResult> PredictPOIOutcome;
+			typedef std::future<PredictPOIOutcome> PredictPOIOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::PredictPOIRequest&, const PredictPOIOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> PredictPOIAsyncHandler;
 			typedef Outcome<Error, Model::StructureAddressResult> StructureAddressOutcome;
 			typedef std::future<StructureAddressOutcome> StructureAddressOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::StructureAddressRequest&, const StructureAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> StructureAddressAsyncHandler;
+			typedef Outcome<Error, Model::TransferCoordResult> TransferCoordOutcome;
+			typedef std::future<TransferCoordOutcome> TransferCoordOutcomeCallable;
+			typedef std::function<void(const Address_purificationClient*, const Model::TransferCoordRequest&, const TransferCoordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TransferCoordAsyncHandler;
 			typedef Outcome<Error, Model::UpdateProjectResult> UpdateProjectOutcome;
 			typedef std::future<UpdateProjectOutcome> UpdateProjectOutcomeCallable;
 			typedef std::function<void(const Address_purificationClient*, const Model::UpdateProjectRequest&, const UpdateProjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateProjectAsyncHandler;
@@ -103,24 +143,48 @@ namespace AlibabaCloud
 			ExtractAddressOutcome extractAddress(const Model::ExtractAddressRequest &request)const;
 			void extractAddressAsync(const Model::ExtractAddressRequest& request, const ExtractAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExtractAddressOutcomeCallable extractAddressCallable(const Model::ExtractAddressRequest& request) const;
+			ExtractExpressOutcome extractExpress(const Model::ExtractExpressRequest &request)const;
+			void extractExpressAsync(const Model::ExtractExpressRequest& request, const ExtractExpressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ExtractExpressOutcomeCallable extractExpressCallable(const Model::ExtractExpressRequest& request) const;
 			ExtractNameOutcome extractName(const Model::ExtractNameRequest &request)const;
 			void extractNameAsync(const Model::ExtractNameRequest& request, const ExtractNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExtractNameOutcomeCallable extractNameCallable(const Model::ExtractNameRequest& request) const;
 			ExtractPhoneOutcome extractPhone(const Model::ExtractPhoneRequest &request)const;
 			void extractPhoneAsync(const Model::ExtractPhoneRequest& request, const ExtractPhoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExtractPhoneOutcomeCallable extractPhoneCallable(const Model::ExtractPhoneRequest& request) const;
+			GetAddressBlockMappingOutcome getAddressBlockMapping(const Model::GetAddressBlockMappingRequest &request)const;
+			void getAddressBlockMappingAsync(const Model::GetAddressBlockMappingRequest& request, const GetAddressBlockMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAddressBlockMappingOutcomeCallable getAddressBlockMappingCallable(const Model::GetAddressBlockMappingRequest& request) const;
 			GetAddressDivisionCodeOutcome getAddressDivisionCode(const Model::GetAddressDivisionCodeRequest &request)const;
 			void getAddressDivisionCodeAsync(const Model::GetAddressDivisionCodeRequest& request, const GetAddressDivisionCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAddressDivisionCodeOutcomeCallable getAddressDivisionCodeCallable(const Model::GetAddressDivisionCodeRequest& request) const;
+			GetAddressEvaluateOutcome getAddressEvaluate(const Model::GetAddressEvaluateRequest &request)const;
+			void getAddressEvaluateAsync(const Model::GetAddressEvaluateRequest& request, const GetAddressEvaluateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAddressEvaluateOutcomeCallable getAddressEvaluateCallable(const Model::GetAddressEvaluateRequest& request) const;
+			GetAddressGeocodeOutcome getAddressGeocode(const Model::GetAddressGeocodeRequest &request)const;
+			void getAddressGeocodeAsync(const Model::GetAddressGeocodeRequest& request, const GetAddressGeocodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAddressGeocodeOutcomeCallable getAddressGeocodeCallable(const Model::GetAddressGeocodeRequest& request) const;
+			GetAddressSearchOutcome getAddressSearch(const Model::GetAddressSearchRequest &request)const;
+			void getAddressSearchAsync(const Model::GetAddressSearchRequest& request, const GetAddressSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAddressSearchOutcomeCallable getAddressSearchCallable(const Model::GetAddressSearchRequest& request) const;
 			GetAddressSimilarityOutcome getAddressSimilarity(const Model::GetAddressSimilarityRequest &request)const;
 			void getAddressSimilarityAsync(const Model::GetAddressSimilarityRequest& request, const GetAddressSimilarityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetAddressSimilarityOutcomeCallable getAddressSimilarityCallable(const Model::GetAddressSimilarityRequest& request) const;
+			GetInputSearchOutcome getInputSearch(const Model::GetInputSearchRequest &request)const;
+			void getInputSearchAsync(const Model::GetInputSearchRequest& request, const GetInputSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetInputSearchOutcomeCallable getInputSearchCallable(const Model::GetInputSearchRequest& request) const;
 			GetZipcodeOutcome getZipcode(const Model::GetZipcodeRequest &request)const;
 			void getZipcodeAsync(const Model::GetZipcodeRequest& request, const GetZipcodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetZipcodeOutcomeCallable getZipcodeCallable(const Model::GetZipcodeRequest& request) const;
+			PredictPOIOutcome predictPOI(const Model::PredictPOIRequest &request)const;
+			void predictPOIAsync(const Model::PredictPOIRequest& request, const PredictPOIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			PredictPOIOutcomeCallable predictPOICallable(const Model::PredictPOIRequest& request) const;
 			StructureAddressOutcome structureAddress(const Model::StructureAddressRequest &request)const;
 			void structureAddressAsync(const Model::StructureAddressRequest& request, const StructureAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			StructureAddressOutcomeCallable structureAddressCallable(const Model::StructureAddressRequest& request) const;
+			TransferCoordOutcome transferCoord(const Model::TransferCoordRequest &request)const;
+			void transferCoordAsync(const Model::TransferCoordRequest& request, const TransferCoordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			TransferCoordOutcomeCallable transferCoordCallable(const Model::TransferCoordRequest& request) const;
 			UpdateProjectOutcome updateProject(const Model::UpdateProjectRequest &request)const;
 			void updateProjectAsync(const Model::UpdateProjectRequest& request, const UpdateProjectAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateProjectOutcomeCallable updateProjectCallable(const Model::UpdateProjectRequest& request) const;

address-purification/include/alibabacloud/address-purification/model/ExtractExpressRequest.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_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ExtractExpressRequest : public RpcServiceRequest
+			{
+
+			public:
+				ExtractExpressRequest();
+				~ExtractExpressRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/ExtractExpressResult.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_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT ExtractExpressResult : public ServiceResult
+			{
+			public:
+
+
+				ExtractExpressResult();
+				explicit ExtractExpressResult(const std::string &payload);
+				~ExtractExpressResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_EXTRACTEXPRESSRESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressBlockMappingRequest.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_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressBlockMappingRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAddressBlockMappingRequest();
+				~GetAddressBlockMappingRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressBlockMappingResult.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_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressBlockMappingResult : public ServiceResult
+			{
+			public:
+
+
+				GetAddressBlockMappingResult();
+				explicit GetAddressBlockMappingResult(const std::string &payload);
+				~GetAddressBlockMappingResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSBLOCKMAPPINGRESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressEvaluateRequest.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_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATEREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressEvaluateRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAddressEvaluateRequest();
+				~GetAddressEvaluateRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATEREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressEvaluateResult.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_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATERESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressEvaluateResult : public ServiceResult
+			{
+			public:
+
+
+				GetAddressEvaluateResult();
+				explicit GetAddressEvaluateResult(const std::string &payload);
+				~GetAddressEvaluateResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSEVALUATERESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressGeocodeRequest.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_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODEREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressGeocodeRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAddressGeocodeRequest();
+				~GetAddressGeocodeRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODEREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressGeocodeResult.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_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODERESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressGeocodeResult : public ServiceResult
+			{
+			public:
+
+
+				GetAddressGeocodeResult();
+				explicit GetAddressGeocodeResult(const std::string &payload);
+				~GetAddressGeocodeResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSGEOCODERESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressSearchRequest.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_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressSearchRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetAddressSearchRequest();
+				~GetAddressSearchRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetAddressSearchResult.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_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetAddressSearchResult : public ServiceResult
+			{
+			public:
+
+
+				GetAddressSearchResult();
+				explicit GetAddressSearchResult(const std::string &payload);
+				~GetAddressSearchResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETADDRESSSEARCHRESULT_H_

address-purification/include/alibabacloud/address-purification/model/GetInputSearchRequest.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_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetInputSearchRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetInputSearchRequest();
+				~GetInputSearchRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/GetInputSearchResult.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_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT GetInputSearchResult : public ServiceResult
+			{
+			public:
+
+
+				GetInputSearchResult();
+				explicit GetInputSearchResult(const std::string &payload);
+				~GetInputSearchResult();
+				std::string getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_GETINPUTSEARCHRESULT_H_

address-purification/include/alibabacloud/address-purification/model/PredictPOIRequest.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_ADDRESS_PURIFICATION_MODEL_PREDICTPOIREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT PredictPOIRequest : public RpcServiceRequest
+			{
+
+			public:
+				PredictPOIRequest();
+				~PredictPOIRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+				std::string getText()const;
+				void setText(const std::string& text);
+
+            private:
+				std::string defaultProvince_;
+				std::string serviceCode_;
+				std::string defaultCity_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+				std::string text_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/PredictPOIResult.h

@@ -14,29 +14,29 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DRDS_MODEL_ROLLBACKHISTOREINSTANCERESULT_H_
-#define ALIBABACLOUD_DRDS_MODEL_ROLLBACKHISTOREINSTANCERESULT_H_
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIRESULT_H_
 
 #include <string>
 #include <vector>
 #include <utility>
 #include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/drds/DrdsExport.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Drds
+	namespace Address_purification
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DRDS_EXPORT RollbackHiStoreInstanceResult : public ServiceResult
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT PredictPOIResult : public ServiceResult
 			{
 			public:
 
 
-				RollbackHiStoreInstanceResult();
-				explicit RollbackHiStoreInstanceResult(const std::string &payload);
-				~RollbackHiStoreInstanceResult();
+				PredictPOIResult();
+				explicit PredictPOIResult(const std::string &payload);
+				~PredictPOIResult();
 				std::string getData()const;
 
 			protected:
@@ -48,4 +48,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DRDS_MODEL_ROLLBACKHISTOREINSTANCERESULT_H_
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_PREDICTPOIRESULT_H_

address-purification/include/alibabacloud/address-purification/model/TransferCoordRequest.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_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDREQUEST_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Address_purification
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT TransferCoordRequest : public RpcServiceRequest
+			{
+
+			public:
+				TransferCoordRequest();
+				~TransferCoordRequest();
+
+				std::string getDefaultProvince()const;
+				void setDefaultProvince(const std::string& defaultProvince);
+				std::string getSrcCoord()const;
+				void setSrcCoord(const std::string& srcCoord);
+				std::string getDefaultCity()const;
+				void setDefaultCity(const std::string& defaultCity);
+				std::string getText()const;
+				void setText(const std::string& text);
+				std::string getServiceCode()const;
+				void setServiceCode(const std::string& serviceCode);
+				std::string getDefaultDistrict()const;
+				void setDefaultDistrict(const std::string& defaultDistrict);
+				std::string getAppKey()const;
+				void setAppKey(const std::string& appKey);
+
+            private:
+				std::string defaultProvince_;
+				std::string srcCoord_;
+				std::string defaultCity_;
+				std::string text_;
+				std::string serviceCode_;
+				std::string defaultDistrict_;
+				std::string appKey_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDREQUEST_H_

address-purification/include/alibabacloud/address-purification/model/TransferCoordResult.h

@@ -14,29 +14,29 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DRDS_MODEL_ROLLBACKINSTANCEVERSIONRESULT_H_
-#define ALIBABACLOUD_DRDS_MODEL_ROLLBACKINSTANCEVERSIONRESULT_H_
+#ifndef ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDRESULT_H_
+#define ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDRESULT_H_
 
 #include <string>
 #include <vector>
 #include <utility>
 #include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/drds/DrdsExport.h>
+#include <alibabacloud/address-purification/Address_purificationExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Drds
+	namespace Address_purification
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DRDS_EXPORT RollbackInstanceVersionResult : public ServiceResult
+			class ALIBABACLOUD_ADDRESS_PURIFICATION_EXPORT TransferCoordResult : public ServiceResult
 			{
 			public:
 
 
-				RollbackInstanceVersionResult();
-				explicit RollbackInstanceVersionResult(const std::string &payload);
-				~RollbackInstanceVersionResult();
+				TransferCoordResult();
+				explicit TransferCoordResult(const std::string &payload);
+				~TransferCoordResult();
 				std::string getData()const;
 
 			protected:
@@ -48,4 +48,4 @@ namespace AlibabaCloud
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DRDS_MODEL_ROLLBACKINSTANCEVERSIONRESULT_H_
+#endif // !ALIBABACLOUD_ADDRESS_PURIFICATION_MODEL_TRANSFERCOORDRESULT_H_

address-purification/src/Address-purificationClient.cc

@@ -195,6 +195,42 @@ Address_purificationClient::ExtractAddressOutcomeCallable Address_purificationCl
 	return task->get_future();
 }
 
+Address_purificationClient::ExtractExpressOutcome Address_purificationClient::extractExpress(const ExtractExpressRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ExtractExpressOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ExtractExpressOutcome(ExtractExpressResult(outcome.result()));
+	else
+		return ExtractExpressOutcome(outcome.error());
+}
+
+void Address_purificationClient::extractExpressAsync(const ExtractExpressRequest& request, const ExtractExpressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, extractExpress(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::ExtractExpressOutcomeCallable Address_purificationClient::extractExpressCallable(const ExtractExpressRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ExtractExpressOutcome()>>(
+			[this, request]()
+			{
+			return this->extractExpress(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::ExtractNameOutcome Address_purificationClient::extractName(const ExtractNameRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -267,6 +303,42 @@ Address_purificationClient::ExtractPhoneOutcomeCallable Address_purificationClie
 	return task->get_future();
 }
 
+Address_purificationClient::GetAddressBlockMappingOutcome Address_purificationClient::getAddressBlockMapping(const GetAddressBlockMappingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAddressBlockMappingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAddressBlockMappingOutcome(GetAddressBlockMappingResult(outcome.result()));
+	else
+		return GetAddressBlockMappingOutcome(outcome.error());
+}
+
+void Address_purificationClient::getAddressBlockMappingAsync(const GetAddressBlockMappingRequest& request, const GetAddressBlockMappingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAddressBlockMapping(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetAddressBlockMappingOutcomeCallable Address_purificationClient::getAddressBlockMappingCallable(const GetAddressBlockMappingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAddressBlockMappingOutcome()>>(
+			[this, request]()
+			{
+			return this->getAddressBlockMapping(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::GetAddressDivisionCodeOutcome Address_purificationClient::getAddressDivisionCode(const GetAddressDivisionCodeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -303,6 +375,114 @@ Address_purificationClient::GetAddressDivisionCodeOutcomeCallable Address_purifi
 	return task->get_future();
 }
 
+Address_purificationClient::GetAddressEvaluateOutcome Address_purificationClient::getAddressEvaluate(const GetAddressEvaluateRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAddressEvaluateOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAddressEvaluateOutcome(GetAddressEvaluateResult(outcome.result()));
+	else
+		return GetAddressEvaluateOutcome(outcome.error());
+}
+
+void Address_purificationClient::getAddressEvaluateAsync(const GetAddressEvaluateRequest& request, const GetAddressEvaluateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAddressEvaluate(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetAddressEvaluateOutcomeCallable Address_purificationClient::getAddressEvaluateCallable(const GetAddressEvaluateRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAddressEvaluateOutcome()>>(
+			[this, request]()
+			{
+			return this->getAddressEvaluate(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Address_purificationClient::GetAddressGeocodeOutcome Address_purificationClient::getAddressGeocode(const GetAddressGeocodeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAddressGeocodeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAddressGeocodeOutcome(GetAddressGeocodeResult(outcome.result()));
+	else
+		return GetAddressGeocodeOutcome(outcome.error());
+}
+
+void Address_purificationClient::getAddressGeocodeAsync(const GetAddressGeocodeRequest& request, const GetAddressGeocodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAddressGeocode(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetAddressGeocodeOutcomeCallable Address_purificationClient::getAddressGeocodeCallable(const GetAddressGeocodeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAddressGeocodeOutcome()>>(
+			[this, request]()
+			{
+			return this->getAddressGeocode(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+Address_purificationClient::GetAddressSearchOutcome Address_purificationClient::getAddressSearch(const GetAddressSearchRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAddressSearchOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAddressSearchOutcome(GetAddressSearchResult(outcome.result()));
+	else
+		return GetAddressSearchOutcome(outcome.error());
+}
+
+void Address_purificationClient::getAddressSearchAsync(const GetAddressSearchRequest& request, const GetAddressSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAddressSearch(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetAddressSearchOutcomeCallable Address_purificationClient::getAddressSearchCallable(const GetAddressSearchRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAddressSearchOutcome()>>(
+			[this, request]()
+			{
+			return this->getAddressSearch(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::GetAddressSimilarityOutcome Address_purificationClient::getAddressSimilarity(const GetAddressSimilarityRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +519,42 @@ Address_purificationClient::GetAddressSimilarityOutcomeCallable Address_purifica
 	return task->get_future();
 }
 
+Address_purificationClient::GetInputSearchOutcome Address_purificationClient::getInputSearch(const GetInputSearchRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetInputSearchOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetInputSearchOutcome(GetInputSearchResult(outcome.result()));
+	else
+		return GetInputSearchOutcome(outcome.error());
+}
+
+void Address_purificationClient::getInputSearchAsync(const GetInputSearchRequest& request, const GetInputSearchAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getInputSearch(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::GetInputSearchOutcomeCallable Address_purificationClient::getInputSearchCallable(const GetInputSearchRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetInputSearchOutcome()>>(
+			[this, request]()
+			{
+			return this->getInputSearch(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::GetZipcodeOutcome Address_purificationClient::getZipcode(const GetZipcodeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -375,6 +591,42 @@ Address_purificationClient::GetZipcodeOutcomeCallable Address_purificationClient
 	return task->get_future();
 }
 
+Address_purificationClient::PredictPOIOutcome Address_purificationClient::predictPOI(const PredictPOIRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return PredictPOIOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return PredictPOIOutcome(PredictPOIResult(outcome.result()));
+	else
+		return PredictPOIOutcome(outcome.error());
+}
+
+void Address_purificationClient::predictPOIAsync(const PredictPOIRequest& request, const PredictPOIAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, predictPOI(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::PredictPOIOutcomeCallable Address_purificationClient::predictPOICallable(const PredictPOIRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<PredictPOIOutcome()>>(
+			[this, request]()
+			{
+			return this->predictPOI(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::StructureAddressOutcome Address_purificationClient::structureAddress(const StructureAddressRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -411,6 +663,42 @@ Address_purificationClient::StructureAddressOutcomeCallable Address_purification
 	return task->get_future();
 }
 
+Address_purificationClient::TransferCoordOutcome Address_purificationClient::transferCoord(const TransferCoordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return TransferCoordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return TransferCoordOutcome(TransferCoordResult(outcome.result()));
+	else
+		return TransferCoordOutcome(outcome.error());
+}
+
+void Address_purificationClient::transferCoordAsync(const TransferCoordRequest& request, const TransferCoordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, transferCoord(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+Address_purificationClient::TransferCoordOutcomeCallable Address_purificationClient::transferCoordCallable(const TransferCoordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<TransferCoordOutcome()>>(
+			[this, request]()
+			{
+			return this->transferCoord(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 Address_purificationClient::UpdateProjectOutcome Address_purificationClient::updateProject(const UpdateProjectRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

address-purification/src/model/ExtractExpressRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/ExtractExpressRequest.h>
+
+using AlibabaCloud::Address_purification::Model::ExtractExpressRequest;
+
+ExtractExpressRequest::ExtractExpressRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "ExtractExpress")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ExtractExpressRequest::~ExtractExpressRequest()
+{}
+
+std::string ExtractExpressRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void ExtractExpressRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string ExtractExpressRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void ExtractExpressRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string ExtractExpressRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void ExtractExpressRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string ExtractExpressRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void ExtractExpressRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string ExtractExpressRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void ExtractExpressRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string ExtractExpressRequest::getText()const
+{
+	return text_;
+}
+
+void ExtractExpressRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

address-purification/src/model/ExtractExpressResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/drds/model/RollbackHiStoreInstanceResult.h>
+#include <alibabacloud/address-purification/model/ExtractExpressResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::Drds;
-using namespace AlibabaCloud::Drds::Model;
+using namespace AlibabaCloud::Address_purification;
+using namespace AlibabaCloud::Address_purification::Model;
 
-RollbackHiStoreInstanceResult::RollbackHiStoreInstanceResult() :
+ExtractExpressResult::ExtractExpressResult() :
 	ServiceResult()
 {}
 
-RollbackHiStoreInstanceResult::RollbackHiStoreInstanceResult(const std::string &payload) :
+ExtractExpressResult::ExtractExpressResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-RollbackHiStoreInstanceResult::~RollbackHiStoreInstanceResult()
+ExtractExpressResult::~ExtractExpressResult()
 {}
 
-void RollbackHiStoreInstanceResult::parse(const std::string &payload)
+void ExtractExpressResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
@@ -44,7 +44,7 @@ void RollbackHiStoreInstanceResult::parse(const std::string &payload)
 
 }
 
-std::string RollbackHiStoreInstanceResult::getData()const
+std::string ExtractExpressResult::getData()const
 {
 	return data_;
 }

address-purification/src/model/GetAddressBlockMappingRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/GetAddressBlockMappingRequest.h>
+
+using AlibabaCloud::Address_purification::Model::GetAddressBlockMappingRequest;
+
+GetAddressBlockMappingRequest::GetAddressBlockMappingRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "GetAddressBlockMapping")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetAddressBlockMappingRequest::~GetAddressBlockMappingRequest()
+{}
+
+std::string GetAddressBlockMappingRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void GetAddressBlockMappingRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string GetAddressBlockMappingRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void GetAddressBlockMappingRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string GetAddressBlockMappingRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void GetAddressBlockMappingRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string GetAddressBlockMappingRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void GetAddressBlockMappingRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string GetAddressBlockMappingRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void GetAddressBlockMappingRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string GetAddressBlockMappingRequest::getText()const
+{
+	return text_;
+}
+
+void GetAddressBlockMappingRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

address-purification/src/model/GetAddressBlockMappingResult.cc

@@ -14,37 +14,37 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/drds/model/ReleaseHiStoreInstanceResult.h>
+#include <alibabacloud/address-purification/model/GetAddressBlockMappingResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::Drds;
-using namespace AlibabaCloud::Drds::Model;
+using namespace AlibabaCloud::Address_purification;
+using namespace AlibabaCloud::Address_purification::Model;
 
-ReleaseHiStoreInstanceResult::ReleaseHiStoreInstanceResult() :
+GetAddressBlockMappingResult::GetAddressBlockMappingResult() :
 	ServiceResult()
 {}
 
-ReleaseHiStoreInstanceResult::ReleaseHiStoreInstanceResult(const std::string &payload) :
+GetAddressBlockMappingResult::GetAddressBlockMappingResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-ReleaseHiStoreInstanceResult::~ReleaseHiStoreInstanceResult()
+GetAddressBlockMappingResult::~GetAddressBlockMappingResult()
 {}
 
-void ReleaseHiStoreInstanceResult::parse(const std::string &payload)
+void GetAddressBlockMappingResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
 	if(!value["Data"].isNull())
-		data_ = std::stol(value["Data"].asString());
+		data_ = value["Data"].asString();
 
 }
 
-long ReleaseHiStoreInstanceResult::getData()const
+std::string GetAddressBlockMappingResult::getData()const
 {
 	return data_;
 }

address-purification/src/model/GetAddressEvaluateRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/GetAddressEvaluateRequest.h>
+
+using AlibabaCloud::Address_purification::Model::GetAddressEvaluateRequest;
+
+GetAddressEvaluateRequest::GetAddressEvaluateRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "GetAddressEvaluate")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetAddressEvaluateRequest::~GetAddressEvaluateRequest()
+{}
+
+std::string GetAddressEvaluateRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void GetAddressEvaluateRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string GetAddressEvaluateRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void GetAddressEvaluateRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string GetAddressEvaluateRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void GetAddressEvaluateRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string GetAddressEvaluateRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void GetAddressEvaluateRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string GetAddressEvaluateRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void GetAddressEvaluateRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string GetAddressEvaluateRequest::getText()const
+{
+	return text_;
+}
+
+void GetAddressEvaluateRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

address-purification/src/model/GetAddressEvaluateResult.cc

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

address-purification/src/model/GetAddressGeocodeRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/GetAddressGeocodeRequest.h>
+
+using AlibabaCloud::Address_purification::Model::GetAddressGeocodeRequest;
+
+GetAddressGeocodeRequest::GetAddressGeocodeRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "GetAddressGeocode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetAddressGeocodeRequest::~GetAddressGeocodeRequest()
+{}
+
+std::string GetAddressGeocodeRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void GetAddressGeocodeRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string GetAddressGeocodeRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void GetAddressGeocodeRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string GetAddressGeocodeRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void GetAddressGeocodeRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string GetAddressGeocodeRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void GetAddressGeocodeRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string GetAddressGeocodeRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void GetAddressGeocodeRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string GetAddressGeocodeRequest::getText()const
+{
+	return text_;
+}
+
+void GetAddressGeocodeRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

address-purification/src/model/GetAddressGeocodeResult.cc

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

address-purification/src/model/GetAddressSearchRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/GetAddressSearchRequest.h>
+
+using AlibabaCloud::Address_purification::Model::GetAddressSearchRequest;
+
+GetAddressSearchRequest::GetAddressSearchRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "GetAddressSearch")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetAddressSearchRequest::~GetAddressSearchRequest()
+{}
+
+std::string GetAddressSearchRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void GetAddressSearchRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string GetAddressSearchRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void GetAddressSearchRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string GetAddressSearchRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void GetAddressSearchRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string GetAddressSearchRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void GetAddressSearchRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string GetAddressSearchRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void GetAddressSearchRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string GetAddressSearchRequest::getText()const
+{
+	return text_;
+}
+
+void GetAddressSearchRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

address-purification/src/model/GetAddressSearchResult.cc

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

address-purification/src/model/GetInputSearchRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/GetInputSearchRequest.h>
+
+using AlibabaCloud::Address_purification::Model::GetInputSearchRequest;
+
+GetInputSearchRequest::GetInputSearchRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "GetInputSearch")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetInputSearchRequest::~GetInputSearchRequest()
+{}
+
+std::string GetInputSearchRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void GetInputSearchRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string GetInputSearchRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void GetInputSearchRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string GetInputSearchRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void GetInputSearchRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string GetInputSearchRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void GetInputSearchRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string GetInputSearchRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void GetInputSearchRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string GetInputSearchRequest::getText()const
+{
+	return text_;
+}
+
+void GetInputSearchRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

address-purification/src/model/GetInputSearchResult.cc

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

address-purification/src/model/PredictPOIRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/PredictPOIRequest.h>
+
+using AlibabaCloud::Address_purification::Model::PredictPOIRequest;
+
+PredictPOIRequest::PredictPOIRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "PredictPOI")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+PredictPOIRequest::~PredictPOIRequest()
+{}
+
+std::string PredictPOIRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void PredictPOIRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string PredictPOIRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void PredictPOIRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string PredictPOIRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void PredictPOIRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string PredictPOIRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void PredictPOIRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string PredictPOIRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void PredictPOIRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+
+std::string PredictPOIRequest::getText()const
+{
+	return text_;
+}
+
+void PredictPOIRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+

address-purification/src/model/PredictPOIResult.cc

@@ -14,26 +14,26 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/drds/model/RollbackInstanceVersionResult.h>
+#include <alibabacloud/address-purification/model/PredictPOIResult.h>
 #include <json/json.h>
 
-using namespace AlibabaCloud::Drds;
-using namespace AlibabaCloud::Drds::Model;
+using namespace AlibabaCloud::Address_purification;
+using namespace AlibabaCloud::Address_purification::Model;
 
-RollbackInstanceVersionResult::RollbackInstanceVersionResult() :
+PredictPOIResult::PredictPOIResult() :
 	ServiceResult()
 {}
 
-RollbackInstanceVersionResult::RollbackInstanceVersionResult(const std::string &payload) :
+PredictPOIResult::PredictPOIResult(const std::string &payload) :
 	ServiceResult()
 {
 	parse(payload);
 }
 
-RollbackInstanceVersionResult::~RollbackInstanceVersionResult()
+PredictPOIResult::~PredictPOIResult()
 {}
 
-void RollbackInstanceVersionResult::parse(const std::string &payload)
+void PredictPOIResult::parse(const std::string &payload)
 {
 	Json::Reader reader;
 	Json::Value value;
@@ -44,7 +44,7 @@ void RollbackInstanceVersionResult::parse(const std::string &payload)
 
 }
 
-std::string RollbackInstanceVersionResult::getData()const
+std::string PredictPOIResult::getData()const
 {
 	return data_;
 }

address-purification/src/model/TransferCoordRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/address-purification/model/TransferCoordRequest.h>
+
+using AlibabaCloud::Address_purification::Model::TransferCoordRequest;
+
+TransferCoordRequest::TransferCoordRequest() :
+	RpcServiceRequest("address-purification", "2019-11-18", "TransferCoord")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+TransferCoordRequest::~TransferCoordRequest()
+{}
+
+std::string TransferCoordRequest::getDefaultProvince()const
+{
+	return defaultProvince_;
+}
+
+void TransferCoordRequest::setDefaultProvince(const std::string& defaultProvince)
+{
+	defaultProvince_ = defaultProvince;
+	setBodyParameter("DefaultProvince", defaultProvince);
+}
+
+std::string TransferCoordRequest::getSrcCoord()const
+{
+	return srcCoord_;
+}
+
+void TransferCoordRequest::setSrcCoord(const std::string& srcCoord)
+{
+	srcCoord_ = srcCoord;
+	setBodyParameter("SrcCoord", srcCoord);
+}
+
+std::string TransferCoordRequest::getDefaultCity()const
+{
+	return defaultCity_;
+}
+
+void TransferCoordRequest::setDefaultCity(const std::string& defaultCity)
+{
+	defaultCity_ = defaultCity;
+	setBodyParameter("DefaultCity", defaultCity);
+}
+
+std::string TransferCoordRequest::getText()const
+{
+	return text_;
+}
+
+void TransferCoordRequest::setText(const std::string& text)
+{
+	text_ = text;
+	setBodyParameter("Text", text);
+}
+
+std::string TransferCoordRequest::getServiceCode()const
+{
+	return serviceCode_;
+}
+
+void TransferCoordRequest::setServiceCode(const std::string& serviceCode)
+{
+	serviceCode_ = serviceCode;
+	setBodyParameter("ServiceCode", serviceCode);
+}
+
+std::string TransferCoordRequest::getDefaultDistrict()const
+{
+	return defaultDistrict_;
+}
+
+void TransferCoordRequest::setDefaultDistrict(const std::string& defaultDistrict)
+{
+	defaultDistrict_ = defaultDistrict;
+	setBodyParameter("DefaultDistrict", defaultDistrict);
+}
+
+std::string TransferCoordRequest::getAppKey()const
+{
+	return appKey_;
+}
+
+void TransferCoordRequest::setAppKey(const std::string& appKey)
+{
+	appKey_ = appKey;
+	setBodyParameter("AppKey", appKey);
+}
+

address-purification/src/model/TransferCoordResult.cc

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

ccc/CMakeLists.txt

@@ -55,8 +55,16 @@ set(ccc_public_header_model
 	include/alibabacloud/ccc/model/CreateUserResult.h
 	include/alibabacloud/ccc/model/DeleteSkillGroupRequest.h
 	include/alibabacloud/ccc/model/DeleteSkillGroupResult.h
+	include/alibabacloud/ccc/model/GetCallDetailRecordRequest.h
+	include/alibabacloud/ccc/model/GetCallDetailRecordResult.h
+	include/alibabacloud/ccc/model/GetHistoricalCallerReportRequest.h
+	include/alibabacloud/ccc/model/GetHistoricalCallerReportResult.h
+	include/alibabacloud/ccc/model/GetHistoricalInstanceReportRequest.h
+	include/alibabacloud/ccc/model/GetHistoricalInstanceReportResult.h
 	include/alibabacloud/ccc/model/GetInstanceRequest.h
 	include/alibabacloud/ccc/model/GetInstanceResult.h
+	include/alibabacloud/ccc/model/GetInstanceTrendingReportRequest.h
+	include/alibabacloud/ccc/model/GetInstanceTrendingReportResult.h
 	include/alibabacloud/ccc/model/GetLoginDetailsRequest.h
 	include/alibabacloud/ccc/model/GetLoginDetailsResult.h
 	include/alibabacloud/ccc/model/GetMonoRecordingRequest.h
@@ -65,6 +73,8 @@ set(ccc_public_header_model
 	include/alibabacloud/ccc/model/GetMultiChannelRecordingResult.h
 	include/alibabacloud/ccc/model/GetNumberLocationRequest.h
 	include/alibabacloud/ccc/model/GetNumberLocationResult.h
+	include/alibabacloud/ccc/model/GetRealtimeInstanceStatesRequest.h
+	include/alibabacloud/ccc/model/GetRealtimeInstanceStatesResult.h
 	include/alibabacloud/ccc/model/GetTurnCredentialsRequest.h
 	include/alibabacloud/ccc/model/GetTurnCredentialsResult.h
 	include/alibabacloud/ccc/model/GetTurnServerListRequest.h
@@ -81,6 +91,8 @@ set(ccc_public_header_model
 	include/alibabacloud/ccc/model/LaunchAuthenticationResult.h
 	include/alibabacloud/ccc/model/LaunchSurveyRequest.h
 	include/alibabacloud/ccc/model/LaunchSurveyResult.h
+	include/alibabacloud/ccc/model/ListAgentStateLogsRequest.h
+	include/alibabacloud/ccc/model/ListAgentStateLogsResult.h
 	include/alibabacloud/ccc/model/ListBriefSkillGroupsRequest.h
 	include/alibabacloud/ccc/model/ListBriefSkillGroupsResult.h
 	include/alibabacloud/ccc/model/ListCallDetailRecordsRequest.h
@@ -93,8 +105,18 @@ set(ccc_public_header_model
 	include/alibabacloud/ccc/model/ListDevicesResult.h
 	include/alibabacloud/ccc/model/ListHistoricalAgentReportRequest.h
 	include/alibabacloud/ccc/model/ListHistoricalAgentReportResult.h
+	include/alibabacloud/ccc/model/ListHistoricalSkillGroupReportRequest.h
+	include/alibabacloud/ccc/model/ListHistoricalSkillGroupReportResult.h
 	include/alibabacloud/ccc/model/ListInstancesOfUserRequest.h
 	include/alibabacloud/ccc/model/ListInstancesOfUserResult.h
+	include/alibabacloud/ccc/model/ListIntervalAgentReportRequest.h
+	include/alibabacloud/ccc/model/ListIntervalAgentReportResult.h
+	include/alibabacloud/ccc/model/ListIntervalInstanceReportRequest.h
+	include/alibabacloud/ccc/model/ListIntervalInstanceReportResult.h
+	include/alibabacloud/ccc/model/ListIntervalSkillGroupReportRequest.h
+	include/alibabacloud/ccc/model/ListIntervalSkillGroupReportResult.h
+	include/alibabacloud/ccc/model/ListIvrTrackingDetailsRequest.h
+	include/alibabacloud/ccc/model/ListIvrTrackingDetailsResult.h
 	include/alibabacloud/ccc/model/ListOutboundNumbersOfUserRequest.h
 	include/alibabacloud/ccc/model/ListOutboundNumbersOfUserResult.h
 	include/alibabacloud/ccc/model/ListPersonalNumbersOfUserRequest.h
@@ -107,6 +129,8 @@ set(ccc_public_header_model
 	include/alibabacloud/ccc/model/ListPrivilegesOfUserResult.h
 	include/alibabacloud/ccc/model/ListRealtimeAgentStatesRequest.h
 	include/alibabacloud/ccc/model/ListRealtimeAgentStatesResult.h
+	include/alibabacloud/ccc/model/ListRealtimeSkillGroupStatesRequest.h
+	include/alibabacloud/ccc/model/ListRealtimeSkillGroupStatesResult.h
 	include/alibabacloud/ccc/model/ListRecentCallDetailRecordsRequest.h
 	include/alibabacloud/ccc/model/ListRecentCallDetailRecordsResult.h
 	include/alibabacloud/ccc/model/ListRolesRequest.h
@@ -212,8 +236,16 @@ set(ccc_src
 	src/model/CreateUserResult.cc
 	src/model/DeleteSkillGroupRequest.cc
 	src/model/DeleteSkillGroupResult.cc
+	src/model/GetCallDetailRecordRequest.cc
+	src/model/GetCallDetailRecordResult.cc
+	src/model/GetHistoricalCallerReportRequest.cc
+	src/model/GetHistoricalCallerReportResult.cc
+	src/model/GetHistoricalInstanceReportRequest.cc
+	src/model/GetHistoricalInstanceReportResult.cc
 	src/model/GetInstanceRequest.cc
 	src/model/GetInstanceResult.cc
+	src/model/GetInstanceTrendingReportRequest.cc
+	src/model/GetInstanceTrendingReportResult.cc
 	src/model/GetLoginDetailsRequest.cc
 	src/model/GetLoginDetailsResult.cc
 	src/model/GetMonoRecordingRequest.cc
@@ -222,6 +254,8 @@ set(ccc_src
 	src/model/GetMultiChannelRecordingResult.cc
 	src/model/GetNumberLocationRequest.cc
 	src/model/GetNumberLocationResult.cc
+	src/model/GetRealtimeInstanceStatesRequest.cc
+	src/model/GetRealtimeInstanceStatesResult.cc
 	src/model/GetTurnCredentialsRequest.cc
 	src/model/GetTurnCredentialsResult.cc
 	src/model/GetTurnServerListRequest.cc
@@ -238,6 +272,8 @@ set(ccc_src
 	src/model/LaunchAuthenticationResult.cc
 	src/model/LaunchSurveyRequest.cc
 	src/model/LaunchSurveyResult.cc
+	src/model/ListAgentStateLogsRequest.cc
+	src/model/ListAgentStateLogsResult.cc
 	src/model/ListBriefSkillGroupsRequest.cc
 	src/model/ListBriefSkillGroupsResult.cc
 	src/model/ListCallDetailRecordsRequest.cc
@@ -250,8 +286,18 @@ set(ccc_src
 	src/model/ListDevicesResult.cc
 	src/model/ListHistoricalAgentReportRequest.cc
 	src/model/ListHistoricalAgentReportResult.cc
+	src/model/ListHistoricalSkillGroupReportRequest.cc
+	src/model/ListHistoricalSkillGroupReportResult.cc
 	src/model/ListInstancesOfUserRequest.cc
 	src/model/ListInstancesOfUserResult.cc
+	src/model/ListIntervalAgentReportRequest.cc
+	src/model/ListIntervalAgentReportResult.cc
+	src/model/ListIntervalInstanceReportRequest.cc
+	src/model/ListIntervalInstanceReportResult.cc
+	src/model/ListIntervalSkillGroupReportRequest.cc
+	src/model/ListIntervalSkillGroupReportResult.cc
+	src/model/ListIvrTrackingDetailsRequest.cc
+	src/model/ListIvrTrackingDetailsResult.cc
 	src/model/ListOutboundNumbersOfUserRequest.cc
 	src/model/ListOutboundNumbersOfUserResult.cc
 	src/model/ListPersonalNumbersOfUserRequest.cc
@@ -264,6 +310,8 @@ set(ccc_src
 	src/model/ListPrivilegesOfUserResult.cc
 	src/model/ListRealtimeAgentStatesRequest.cc
 	src/model/ListRealtimeAgentStatesResult.cc
+	src/model/ListRealtimeSkillGroupStatesRequest.cc
+	src/model/ListRealtimeSkillGroupStatesResult.cc
 	src/model/ListRecentCallDetailRecordsRequest.cc
 	src/model/ListRecentCallDetailRecordsResult.cc
 	src/model/ListRolesRequest.cc

ccc/include/alibabacloud/ccc/CCCClient.h

@@ -56,8 +56,16 @@
 #include "model/CreateUserResult.h"
 #include "model/DeleteSkillGroupRequest.h"
 #include "model/DeleteSkillGroupResult.h"
+#include "model/GetCallDetailRecordRequest.h"
+#include "model/GetCallDetailRecordResult.h"
+#include "model/GetHistoricalCallerReportRequest.h"
+#include "model/GetHistoricalCallerReportResult.h"
+#include "model/GetHistoricalInstanceReportRequest.h"
+#include "model/GetHistoricalInstanceReportResult.h"
 #include "model/GetInstanceRequest.h"
 #include "model/GetInstanceResult.h"
+#include "model/GetInstanceTrendingReportRequest.h"
+#include "model/GetInstanceTrendingReportResult.h"
 #include "model/GetLoginDetailsRequest.h"
 #include "model/GetLoginDetailsResult.h"
 #include "model/GetMonoRecordingRequest.h"
@@ -66,6 +74,8 @@
 #include "model/GetMultiChannelRecordingResult.h"
 #include "model/GetNumberLocationRequest.h"
 #include "model/GetNumberLocationResult.h"
+#include "model/GetRealtimeInstanceStatesRequest.h"
+#include "model/GetRealtimeInstanceStatesResult.h"
 #include "model/GetTurnCredentialsRequest.h"
 #include "model/GetTurnCredentialsResult.h"
 #include "model/GetTurnServerListRequest.h"
@@ -82,6 +92,8 @@
 #include "model/LaunchAuthenticationResult.h"
 #include "model/LaunchSurveyRequest.h"
 #include "model/LaunchSurveyResult.h"
+#include "model/ListAgentStateLogsRequest.h"
+#include "model/ListAgentStateLogsResult.h"
 #include "model/ListBriefSkillGroupsRequest.h"
 #include "model/ListBriefSkillGroupsResult.h"
 #include "model/ListCallDetailRecordsRequest.h"
@@ -94,8 +106,18 @@
 #include "model/ListDevicesResult.h"
 #include "model/ListHistoricalAgentReportRequest.h"
 #include "model/ListHistoricalAgentReportResult.h"
+#include "model/ListHistoricalSkillGroupReportRequest.h"
+#include "model/ListHistoricalSkillGroupReportResult.h"
 #include "model/ListInstancesOfUserRequest.h"
 #include "model/ListInstancesOfUserResult.h"
+#include "model/ListIntervalAgentReportRequest.h"
+#include "model/ListIntervalAgentReportResult.h"
+#include "model/ListIntervalInstanceReportRequest.h"
+#include "model/ListIntervalInstanceReportResult.h"
+#include "model/ListIntervalSkillGroupReportRequest.h"
+#include "model/ListIntervalSkillGroupReportResult.h"
+#include "model/ListIvrTrackingDetailsRequest.h"
+#include "model/ListIvrTrackingDetailsResult.h"
 #include "model/ListOutboundNumbersOfUserRequest.h"
 #include "model/ListOutboundNumbersOfUserResult.h"
 #include "model/ListPersonalNumbersOfUserRequest.h"
@@ -108,6 +130,8 @@
 #include "model/ListPrivilegesOfUserResult.h"
 #include "model/ListRealtimeAgentStatesRequest.h"
 #include "model/ListRealtimeAgentStatesResult.h"
+#include "model/ListRealtimeSkillGroupStatesRequest.h"
+#include "model/ListRealtimeSkillGroupStatesResult.h"
 #include "model/ListRecentCallDetailRecordsRequest.h"
 #include "model/ListRecentCallDetailRecordsResult.h"
 #include "model/ListRolesRequest.h"
@@ -236,9 +260,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DeleteSkillGroupResult> DeleteSkillGroupOutcome;
 			typedef std::future<DeleteSkillGroupOutcome> DeleteSkillGroupOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::DeleteSkillGroupRequest&, const DeleteSkillGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteSkillGroupAsyncHandler;
+			typedef Outcome<Error, Model::GetCallDetailRecordResult> GetCallDetailRecordOutcome;
+			typedef std::future<GetCallDetailRecordOutcome> GetCallDetailRecordOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::GetCallDetailRecordRequest&, const GetCallDetailRecordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetCallDetailRecordAsyncHandler;
+			typedef Outcome<Error, Model::GetHistoricalCallerReportResult> GetHistoricalCallerReportOutcome;
+			typedef std::future<GetHistoricalCallerReportOutcome> GetHistoricalCallerReportOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::GetHistoricalCallerReportRequest&, const GetHistoricalCallerReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetHistoricalCallerReportAsyncHandler;
+			typedef Outcome<Error, Model::GetHistoricalInstanceReportResult> GetHistoricalInstanceReportOutcome;
+			typedef std::future<GetHistoricalInstanceReportOutcome> GetHistoricalInstanceReportOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::GetHistoricalInstanceReportRequest&, const GetHistoricalInstanceReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetHistoricalInstanceReportAsyncHandler;
 			typedef Outcome<Error, Model::GetInstanceResult> GetInstanceOutcome;
 			typedef std::future<GetInstanceOutcome> GetInstanceOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::GetInstanceRequest&, const GetInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInstanceAsyncHandler;
+			typedef Outcome<Error, Model::GetInstanceTrendingReportResult> GetInstanceTrendingReportOutcome;
+			typedef std::future<GetInstanceTrendingReportOutcome> GetInstanceTrendingReportOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::GetInstanceTrendingReportRequest&, const GetInstanceTrendingReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInstanceTrendingReportAsyncHandler;
 			typedef Outcome<Error, Model::GetLoginDetailsResult> GetLoginDetailsOutcome;
 			typedef std::future<GetLoginDetailsOutcome> GetLoginDetailsOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::GetLoginDetailsRequest&, const GetLoginDetailsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetLoginDetailsAsyncHandler;
@@ -251,6 +287,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::GetNumberLocationResult> GetNumberLocationOutcome;
 			typedef std::future<GetNumberLocationOutcome> GetNumberLocationOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::GetNumberLocationRequest&, const GetNumberLocationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNumberLocationAsyncHandler;
+			typedef Outcome<Error, Model::GetRealtimeInstanceStatesResult> GetRealtimeInstanceStatesOutcome;
+			typedef std::future<GetRealtimeInstanceStatesOutcome> GetRealtimeInstanceStatesOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::GetRealtimeInstanceStatesRequest&, const GetRealtimeInstanceStatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetRealtimeInstanceStatesAsyncHandler;
 			typedef Outcome<Error, Model::GetTurnCredentialsResult> GetTurnCredentialsOutcome;
 			typedef std::future<GetTurnCredentialsOutcome> GetTurnCredentialsOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::GetTurnCredentialsRequest&, const GetTurnCredentialsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTurnCredentialsAsyncHandler;
@@ -275,6 +314,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::LaunchSurveyResult> LaunchSurveyOutcome;
 			typedef std::future<LaunchSurveyOutcome> LaunchSurveyOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::LaunchSurveyRequest&, const LaunchSurveyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LaunchSurveyAsyncHandler;
+			typedef Outcome<Error, Model::ListAgentStateLogsResult> ListAgentStateLogsOutcome;
+			typedef std::future<ListAgentStateLogsOutcome> ListAgentStateLogsOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::ListAgentStateLogsRequest&, const ListAgentStateLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAgentStateLogsAsyncHandler;
 			typedef Outcome<Error, Model::ListBriefSkillGroupsResult> ListBriefSkillGroupsOutcome;
 			typedef std::future<ListBriefSkillGroupsOutcome> ListBriefSkillGroupsOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::ListBriefSkillGroupsRequest&, const ListBriefSkillGroupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListBriefSkillGroupsAsyncHandler;
@@ -293,9 +335,24 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListHistoricalAgentReportResult> ListHistoricalAgentReportOutcome;
 			typedef std::future<ListHistoricalAgentReportOutcome> ListHistoricalAgentReportOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::ListHistoricalAgentReportRequest&, const ListHistoricalAgentReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListHistoricalAgentReportAsyncHandler;
+			typedef Outcome<Error, Model::ListHistoricalSkillGroupReportResult> ListHistoricalSkillGroupReportOutcome;
+			typedef std::future<ListHistoricalSkillGroupReportOutcome> ListHistoricalSkillGroupReportOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::ListHistoricalSkillGroupReportRequest&, const ListHistoricalSkillGroupReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListHistoricalSkillGroupReportAsyncHandler;
 			typedef Outcome<Error, Model::ListInstancesOfUserResult> ListInstancesOfUserOutcome;
 			typedef std::future<ListInstancesOfUserOutcome> ListInstancesOfUserOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::ListInstancesOfUserRequest&, const ListInstancesOfUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListInstancesOfUserAsyncHandler;
+			typedef Outcome<Error, Model::ListIntervalAgentReportResult> ListIntervalAgentReportOutcome;
+			typedef std::future<ListIntervalAgentReportOutcome> ListIntervalAgentReportOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::ListIntervalAgentReportRequest&, const ListIntervalAgentReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListIntervalAgentReportAsyncHandler;
+			typedef Outcome<Error, Model::ListIntervalInstanceReportResult> ListIntervalInstanceReportOutcome;
+			typedef std::future<ListIntervalInstanceReportOutcome> ListIntervalInstanceReportOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::ListIntervalInstanceReportRequest&, const ListIntervalInstanceReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListIntervalInstanceReportAsyncHandler;
+			typedef Outcome<Error, Model::ListIntervalSkillGroupReportResult> ListIntervalSkillGroupReportOutcome;
+			typedef std::future<ListIntervalSkillGroupReportOutcome> ListIntervalSkillGroupReportOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::ListIntervalSkillGroupReportRequest&, const ListIntervalSkillGroupReportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListIntervalSkillGroupReportAsyncHandler;
+			typedef Outcome<Error, Model::ListIvrTrackingDetailsResult> ListIvrTrackingDetailsOutcome;
+			typedef std::future<ListIvrTrackingDetailsOutcome> ListIvrTrackingDetailsOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::ListIvrTrackingDetailsRequest&, const ListIvrTrackingDetailsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListIvrTrackingDetailsAsyncHandler;
 			typedef Outcome<Error, Model::ListOutboundNumbersOfUserResult> ListOutboundNumbersOfUserOutcome;
 			typedef std::future<ListOutboundNumbersOfUserOutcome> ListOutboundNumbersOfUserOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::ListOutboundNumbersOfUserRequest&, const ListOutboundNumbersOfUserOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListOutboundNumbersOfUserAsyncHandler;
@@ -314,6 +371,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ListRealtimeAgentStatesResult> ListRealtimeAgentStatesOutcome;
 			typedef std::future<ListRealtimeAgentStatesOutcome> ListRealtimeAgentStatesOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::ListRealtimeAgentStatesRequest&, const ListRealtimeAgentStatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRealtimeAgentStatesAsyncHandler;
+			typedef Outcome<Error, Model::ListRealtimeSkillGroupStatesResult> ListRealtimeSkillGroupStatesOutcome;
+			typedef std::future<ListRealtimeSkillGroupStatesOutcome> ListRealtimeSkillGroupStatesOutcomeCallable;
+			typedef std::function<void(const CCCClient*, const Model::ListRealtimeSkillGroupStatesRequest&, const ListRealtimeSkillGroupStatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRealtimeSkillGroupStatesAsyncHandler;
 			typedef Outcome<Error, Model::ListRecentCallDetailRecordsResult> ListRecentCallDetailRecordsOutcome;
 			typedef std::future<ListRecentCallDetailRecordsOutcome> ListRecentCallDetailRecordsOutcomeCallable;
 			typedef std::function<void(const CCCClient*, const Model::ListRecentCallDetailRecordsRequest&, const ListRecentCallDetailRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListRecentCallDetailRecordsAsyncHandler;
@@ -472,9 +532,21 @@ namespace AlibabaCloud
 			DeleteSkillGroupOutcome deleteSkillGroup(const Model::DeleteSkillGroupRequest &request)const;
 			void deleteSkillGroupAsync(const Model::DeleteSkillGroupRequest& request, const DeleteSkillGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DeleteSkillGroupOutcomeCallable deleteSkillGroupCallable(const Model::DeleteSkillGroupRequest& request) const;
+			GetCallDetailRecordOutcome getCallDetailRecord(const Model::GetCallDetailRecordRequest &request)const;
+			void getCallDetailRecordAsync(const Model::GetCallDetailRecordRequest& request, const GetCallDetailRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetCallDetailRecordOutcomeCallable getCallDetailRecordCallable(const Model::GetCallDetailRecordRequest& request) const;
+			GetHistoricalCallerReportOutcome getHistoricalCallerReport(const Model::GetHistoricalCallerReportRequest &request)const;
+			void getHistoricalCallerReportAsync(const Model::GetHistoricalCallerReportRequest& request, const GetHistoricalCallerReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetHistoricalCallerReportOutcomeCallable getHistoricalCallerReportCallable(const Model::GetHistoricalCallerReportRequest& request) const;
+			GetHistoricalInstanceReportOutcome getHistoricalInstanceReport(const Model::GetHistoricalInstanceReportRequest &request)const;
+			void getHistoricalInstanceReportAsync(const Model::GetHistoricalInstanceReportRequest& request, const GetHistoricalInstanceReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetHistoricalInstanceReportOutcomeCallable getHistoricalInstanceReportCallable(const Model::GetHistoricalInstanceReportRequest& request) const;
 			GetInstanceOutcome getInstance(const Model::GetInstanceRequest &request)const;
 			void getInstanceAsync(const Model::GetInstanceRequest& request, const GetInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetInstanceOutcomeCallable getInstanceCallable(const Model::GetInstanceRequest& request) const;
+			GetInstanceTrendingReportOutcome getInstanceTrendingReport(const Model::GetInstanceTrendingReportRequest &request)const;
+			void getInstanceTrendingReportAsync(const Model::GetInstanceTrendingReportRequest& request, const GetInstanceTrendingReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetInstanceTrendingReportOutcomeCallable getInstanceTrendingReportCallable(const Model::GetInstanceTrendingReportRequest& request) const;
 			GetLoginDetailsOutcome getLoginDetails(const Model::GetLoginDetailsRequest &request)const;
 			void getLoginDetailsAsync(const Model::GetLoginDetailsRequest& request, const GetLoginDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetLoginDetailsOutcomeCallable getLoginDetailsCallable(const Model::GetLoginDetailsRequest& request) const;
@@ -487,6 +559,9 @@ namespace AlibabaCloud
 			GetNumberLocationOutcome getNumberLocation(const Model::GetNumberLocationRequest &request)const;
 			void getNumberLocationAsync(const Model::GetNumberLocationRequest& request, const GetNumberLocationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetNumberLocationOutcomeCallable getNumberLocationCallable(const Model::GetNumberLocationRequest& request) const;
+			GetRealtimeInstanceStatesOutcome getRealtimeInstanceStates(const Model::GetRealtimeInstanceStatesRequest &request)const;
+			void getRealtimeInstanceStatesAsync(const Model::GetRealtimeInstanceStatesRequest& request, const GetRealtimeInstanceStatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetRealtimeInstanceStatesOutcomeCallable getRealtimeInstanceStatesCallable(const Model::GetRealtimeInstanceStatesRequest& request) const;
 			GetTurnCredentialsOutcome getTurnCredentials(const Model::GetTurnCredentialsRequest &request)const;
 			void getTurnCredentialsAsync(const Model::GetTurnCredentialsRequest& request, const GetTurnCredentialsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GetTurnCredentialsOutcomeCallable getTurnCredentialsCallable(const Model::GetTurnCredentialsRequest& request) const;
@@ -511,6 +586,9 @@ namespace AlibabaCloud
 			LaunchSurveyOutcome launchSurvey(const Model::LaunchSurveyRequest &request)const;
 			void launchSurveyAsync(const Model::LaunchSurveyRequest& request, const LaunchSurveyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			LaunchSurveyOutcomeCallable launchSurveyCallable(const Model::LaunchSurveyRequest& request) const;
+			ListAgentStateLogsOutcome listAgentStateLogs(const Model::ListAgentStateLogsRequest &request)const;
+			void listAgentStateLogsAsync(const Model::ListAgentStateLogsRequest& request, const ListAgentStateLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListAgentStateLogsOutcomeCallable listAgentStateLogsCallable(const Model::ListAgentStateLogsRequest& request) const;
 			ListBriefSkillGroupsOutcome listBriefSkillGroups(const Model::ListBriefSkillGroupsRequest &request)const;
 			void listBriefSkillGroupsAsync(const Model::ListBriefSkillGroupsRequest& request, const ListBriefSkillGroupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListBriefSkillGroupsOutcomeCallable listBriefSkillGroupsCallable(const Model::ListBriefSkillGroupsRequest& request) const;
@@ -529,9 +607,24 @@ namespace AlibabaCloud
 			ListHistoricalAgentReportOutcome listHistoricalAgentReport(const Model::ListHistoricalAgentReportRequest &request)const;
 			void listHistoricalAgentReportAsync(const Model::ListHistoricalAgentReportRequest& request, const ListHistoricalAgentReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListHistoricalAgentReportOutcomeCallable listHistoricalAgentReportCallable(const Model::ListHistoricalAgentReportRequest& request) const;
+			ListHistoricalSkillGroupReportOutcome listHistoricalSkillGroupReport(const Model::ListHistoricalSkillGroupReportRequest &request)const;
+			void listHistoricalSkillGroupReportAsync(const Model::ListHistoricalSkillGroupReportRequest& request, const ListHistoricalSkillGroupReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListHistoricalSkillGroupReportOutcomeCallable listHistoricalSkillGroupReportCallable(const Model::ListHistoricalSkillGroupReportRequest& request) const;
 			ListInstancesOfUserOutcome listInstancesOfUser(const Model::ListInstancesOfUserRequest &request)const;
 			void listInstancesOfUserAsync(const Model::ListInstancesOfUserRequest& request, const ListInstancesOfUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListInstancesOfUserOutcomeCallable listInstancesOfUserCallable(const Model::ListInstancesOfUserRequest& request) const;
+			ListIntervalAgentReportOutcome listIntervalAgentReport(const Model::ListIntervalAgentReportRequest &request)const;
+			void listIntervalAgentReportAsync(const Model::ListIntervalAgentReportRequest& request, const ListIntervalAgentReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListIntervalAgentReportOutcomeCallable listIntervalAgentReportCallable(const Model::ListIntervalAgentReportRequest& request) const;
+			ListIntervalInstanceReportOutcome listIntervalInstanceReport(const Model::ListIntervalInstanceReportRequest &request)const;
+			void listIntervalInstanceReportAsync(const Model::ListIntervalInstanceReportRequest& request, const ListIntervalInstanceReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListIntervalInstanceReportOutcomeCallable listIntervalInstanceReportCallable(const Model::ListIntervalInstanceReportRequest& request) const;
+			ListIntervalSkillGroupReportOutcome listIntervalSkillGroupReport(const Model::ListIntervalSkillGroupReportRequest &request)const;
+			void listIntervalSkillGroupReportAsync(const Model::ListIntervalSkillGroupReportRequest& request, const ListIntervalSkillGroupReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListIntervalSkillGroupReportOutcomeCallable listIntervalSkillGroupReportCallable(const Model::ListIntervalSkillGroupReportRequest& request) const;
+			ListIvrTrackingDetailsOutcome listIvrTrackingDetails(const Model::ListIvrTrackingDetailsRequest &request)const;
+			void listIvrTrackingDetailsAsync(const Model::ListIvrTrackingDetailsRequest& request, const ListIvrTrackingDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListIvrTrackingDetailsOutcomeCallable listIvrTrackingDetailsCallable(const Model::ListIvrTrackingDetailsRequest& request) const;
 			ListOutboundNumbersOfUserOutcome listOutboundNumbersOfUser(const Model::ListOutboundNumbersOfUserRequest &request)const;
 			void listOutboundNumbersOfUserAsync(const Model::ListOutboundNumbersOfUserRequest& request, const ListOutboundNumbersOfUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListOutboundNumbersOfUserOutcomeCallable listOutboundNumbersOfUserCallable(const Model::ListOutboundNumbersOfUserRequest& request) const;
@@ -550,6 +643,9 @@ namespace AlibabaCloud
 			ListRealtimeAgentStatesOutcome listRealtimeAgentStates(const Model::ListRealtimeAgentStatesRequest &request)const;
 			void listRealtimeAgentStatesAsync(const Model::ListRealtimeAgentStatesRequest& request, const ListRealtimeAgentStatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListRealtimeAgentStatesOutcomeCallable listRealtimeAgentStatesCallable(const Model::ListRealtimeAgentStatesRequest& request) const;
+			ListRealtimeSkillGroupStatesOutcome listRealtimeSkillGroupStates(const Model::ListRealtimeSkillGroupStatesRequest &request)const;
+			void listRealtimeSkillGroupStatesAsync(const Model::ListRealtimeSkillGroupStatesRequest& request, const ListRealtimeSkillGroupStatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ListRealtimeSkillGroupStatesOutcomeCallable listRealtimeSkillGroupStatesCallable(const Model::ListRealtimeSkillGroupStatesRequest& request) const;
 			ListRecentCallDetailRecordsOutcome listRecentCallDetailRecords(const Model::ListRecentCallDetailRecordsRequest &request)const;
 			void listRecentCallDetailRecordsAsync(const Model::ListRecentCallDetailRecordsRequest& request, const ListRecentCallDetailRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListRecentCallDetailRecordsOutcomeCallable listRecentCallDetailRecordsCallable(const Model::ListRecentCallDetailRecordsRequest& request) const;

ccc/include/alibabacloud/ccc/model/GetCallDetailRecordRequest.h

@@ -14,38 +14,38 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DRDS_MODEL_REMOVEEVALUATETASKREQUEST_H_
-#define ALIBABACLOUD_DRDS_MODEL_REMOVEEVALUATETASKREQUEST_H_
+#ifndef ALIBABACLOUD_CCC_MODEL_GETCALLDETAILRECORDREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_GETCALLDETAILRECORDREQUEST_H_
 
 #include <string>
 #include <vector>
 #include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/drds/DrdsExport.h>
+#include <alibabacloud/ccc/CCCExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Drds
+	namespace CCC
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DRDS_EXPORT RemoveEvaluateTaskRequest : public RpcServiceRequest
+			class ALIBABACLOUD_CCC_EXPORT GetCallDetailRecordRequest : public RpcServiceRequest
 			{
 
 			public:
-				RemoveEvaluateTaskRequest();
-				~RemoveEvaluateTaskRequest();
+				GetCallDetailRecordRequest();
+				~GetCallDetailRecordRequest();
 
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
-				int getTaskId()const;
-				void setTaskId(int taskId);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				std::string getContactId()const;
+				void setContactId(const std::string& contactId);
 
             private:
-				std::string accessKeyId_;
-				int taskId_;
+				std::string instanceId_;
+				std::string contactId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DRDS_MODEL_REMOVEEVALUATETASKREQUEST_H_
+#endif // !ALIBABACLOUD_CCC_MODEL_GETCALLDETAILRECORDREQUEST_H_

ccc/include/alibabacloud/ccc/model/GetCallDetailRecordResult.h

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CCC_MODEL_GETCALLDETAILRECORDRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_GETCALLDETAILRECORDRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT GetCallDetailRecordResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct CdrAgentEventsItem
+					{
+						struct EventSequenceItem
+						{
+							long eventTime;
+							std::string event;
+						};
+						std::vector<CdrAgentEventsItem::EventSequenceItem> eventSequence;
+						std::string agentId;
+						std::string agentName;
+						std::string skillGroupId;
+					};
+					struct CdrIvrEventsItem
+					{
+						struct EventSequenceItem2
+						{
+							long eventTime;
+							std::string event;
+						};
+						std::string flowId;
+						std::vector<CdrIvrEventsItem::EventSequenceItem2> eventSequence1;
+					};
+					struct CdrQueueEventsItem
+					{
+						struct EventSequenceItem4
+						{
+							long eventTime;
+							std::string event;
+						};
+						std::string flowId;
+						std::vector<CdrQueueEventsItem::EventSequenceItem4> eventSequence3;
+						std::string queueId;
+						std::string queueName;
+						int queueType;
+					};
+					std::string skillGroupIds;
+					std::string calledNumber;
+					std::string contactType;
+					std::string contactDisposition;
+					std::string instanceId;
+					std::string releaseInitiator;
+					std::vector<CdrIvrEventsItem> cdrIvrEvents;
+					int satisfaction;
+					long startTime;
+					std::string contactId;
+					long callDuration;
+					std::string callingNumber;
+					long releaseTime;
+					bool recordingReady;
+					std::string skillGroupNames;
+					std::vector<CdrQueueEventsItem> cdrQueueEvents;
+					std::string satisfactionSurveyChannel;
+					std::string agentIds;
+					bool satisfactionSurveyOffered;
+					std::vector<CdrAgentEventsItem> cdrAgentEvents;
+					long establishedTime;
+					std::string agentNames;
+				};
+
+
+				GetCallDetailRecordResult();
+				explicit GetCallDetailRecordResult(const std::string &payload);
+				~GetCallDetailRecordResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_GETCALLDETAILRECORDRESULT_H_

ccc/include/alibabacloud/ccc/model/GetHistoricalCallerReportRequest.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_CCC_MODEL_GETHISTORICALCALLERREPORTREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_GETHISTORICALCALLERREPORTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT GetHistoricalCallerReportRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetHistoricalCallerReportRequest();
+				~GetHistoricalCallerReportRequest();
+
+				long getStopTime()const;
+				void setStopTime(long stopTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				std::string getCallingNumber()const;
+				void setCallingNumber(const std::string& callingNumber);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+
+            private:
+				long stopTime_;
+				long startTime_;
+				std::string callingNumber_;
+				std::string instanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_GETHISTORICALCALLERREPORTREQUEST_H_

ccc/include/alibabacloud/ccc/model/GetHistoricalCallerReportResult.h

@@ -14,51 +14,49 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DRDS_MODEL_DESCRIBEDDLTASKRESULT_H_
-#define ALIBABACLOUD_DRDS_MODEL_DESCRIBEDDLTASKRESULT_H_
+#ifndef ALIBABACLOUD_CCC_MODEL_GETHISTORICALCALLERREPORTRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_GETHISTORICALCALLERREPORTRESULT_H_
 
 #include <string>
 #include <vector>
 #include <utility>
 #include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/drds/DrdsExport.h>
+#include <alibabacloud/ccc/CCCExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Drds
+	namespace CCC
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DRDS_EXPORT DescribeDDLTaskResult : public ServiceResult
+			class ALIBABACLOUD_CCC_EXPORT GetHistoricalCallerReportResult : public ServiceResult
 			{
 			public:
 				struct Data
 				{
-					std::string allowCancel;
-					long gmtCreate;
-					std::string requestId;
-					std::string taskName;
-					std::string errMsg;
-					std::string taskPhase;
-					int taskType;
-					int taskStatus;
-					std::string targetId;
-					std::string taskDetail;
+					long lastCallingTime;
+					long totalCalls;
 				};
 
 
-				DescribeDDLTaskResult();
-				explicit DescribeDDLTaskResult(const std::string &payload);
-				~DescribeDDLTaskResult();
+				GetHistoricalCallerReportResult();
+				explicit GetHistoricalCallerReportResult(const std::string &payload);
+				~GetHistoricalCallerReportResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
 				Data getData()const;
+				std::string getCode()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string message_;
+				int httpStatusCode_;
 				Data data_;
+				std::string code_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DRDS_MODEL_DESCRIBEDDLTASKRESULT_H_
+#endif // !ALIBABACLOUD_CCC_MODEL_GETHISTORICALCALLERREPORTRESULT_H_

ccc/include/alibabacloud/ccc/model/GetHistoricalInstanceReportRequest.h

@@ -14,38 +14,41 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DRDS_MODEL_CREATECUSTOMDATAEXPORTTASKREQUEST_H_
-#define ALIBABACLOUD_DRDS_MODEL_CREATECUSTOMDATAEXPORTTASKREQUEST_H_
+#ifndef ALIBABACLOUD_CCC_MODEL_GETHISTORICALINSTANCEREPORTREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_GETHISTORICALINSTANCEREPORTREQUEST_H_
 
 #include <string>
 #include <vector>
 #include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/drds/DrdsExport.h>
+#include <alibabacloud/ccc/CCCExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Drds
+	namespace CCC
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DRDS_EXPORT CreateCustomDataExportTaskRequest : public RpcServiceRequest
+			class ALIBABACLOUD_CCC_EXPORT GetHistoricalInstanceReportRequest : public RpcServiceRequest
 			{
 
 			public:
-				CreateCustomDataExportTaskRequest();
-				~CreateCustomDataExportTaskRequest();
+				GetHistoricalInstanceReportRequest();
+				~GetHistoricalInstanceReportRequest();
 
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
-				std::string getExportParam()const;
-				void setExportParam(const std::string& exportParam);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
 
             private:
-				std::string accessKeyId_;
-				std::string exportParam_;
+				long endTime_;
+				long startTime_;
+				std::string instanceId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DRDS_MODEL_CREATECUSTOMDATAEXPORTTASKREQUEST_H_
+#endif // !ALIBABACLOUD_CCC_MODEL_GETHISTORICALINSTANCEREPORTREQUEST_H_

ccc/include/alibabacloud/ccc/model/GetHistoricalInstanceReportResult.h

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_CCC_MODEL_GETHISTORICALINSTANCEREPORTRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_GETHISTORICALINSTANCEREPORTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT GetHistoricalInstanceReportResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Inbound
+					{
+						long callsAbandonedInQueue;
+						float serviceLevel20;
+						long totalWorkTime;
+						long callsRinged;
+						long totalHoldTime;
+						float averageHoldTime;
+						long maxAbandonedInIVRTime;
+						long callsAbandoned;
+						long callsOffered;
+						long maxRingTime;
+						long callsHold;
+						float satisfactionIndex;
+						long maxAbandonedInRingTime;
+						long totalRingTime;
+						float handleRate;
+						float averageAbandonedInQueueTime;
+						long callsAbandonedInRinging;
+						long totalAbandonedInIVRTime;
+						float averageWaitTime;
+						long totalTalkTime;
+						long totalAbandonedInRingTime;
+						long callsQueued;
+						long maxTalkTime;
+						float averageAbandonedInIVRTime;
+						long totalAbandonTime;
+						float averageTalkTime;
+						long maxHoldTime;
+						long callsAbandonedInIVR;
+						long callsConsulted;
+						long maxAbandonedInQueueTime;
+						long satisfactionSurveysOffered;
+						long callsHandled;
+						long maxWaitTime;
+						long satisfactionSurveysResponded;
+						long callsTransferred;
+						float averageRingTime;
+						long maxAbandonTime;
+						long totalWaitTime;
+						float averageAbandonTime;
+						float averageAbandonedInRingTime;
+						float averageWorkTime;
+						long totalAbandonedInQueueTime;
+						long maxWorkTime;
+						float abandonRate;
+					};
+					struct Outbound
+					{
+						long totalDialingTime;
+						long totalWorkTime;
+						long totalHoldTime;
+						float averageHoldTime;
+						long callsDialedSuccess;
+						long satisfactionSurveysOffered;
+						int callsHold;
+						float satisfactionIndex;
+						long satisfactionSurveysResponded;
+						float averageDialingTime;
+						long callsAnswered;
+						long callsDialed;
+						long totalTalkTime;
+						long maxDialingTime;
+						long maxTalkTime;
+						float averageWorkTime;
+						long maxWorkTime;
+						float answerRate;
+						float averageTalkTime;
+						long maxHoldTime;
+					};
+					struct Overall
+					{
+						long totalReadyTime;
+						long totalBreakTime;
+						long totalCalls;
+						long totalWorkTime;
+						long totalHoldTime;
+						float averageHoldTime;
+						long satisfactionSurveysOffered;
+						float satisfactionIndex;
+						float averageBreakTime;
+						long satisfactionSurveysResponded;
+						long totalTalkTime;
+						float averageReadyTime;
+						long totalLoggedInTime;
+						long maxTalkTime;
+						float averageWorkTime;
+						long maxReadyTime;
+						long maxBreakTime;
+						long maxWorkTime;
+						float averageTalkTime;
+						long maxHoldTime;
+						float occupancyRate;
+					};
+					Outbound outbound;
+					Overall overall;
+					Inbound inbound;
+				};
+
+
+				GetHistoricalInstanceReportResult();
+				explicit GetHistoricalInstanceReportResult(const std::string &payload);
+				~GetHistoricalInstanceReportResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_GETHISTORICALINSTANCEREPORTRESULT_H_

ccc/include/alibabacloud/ccc/model/GetInstanceTrendingReportRequest.h

@@ -14,41 +14,41 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DRDS_MODEL_DESCRIBERECYCLEBINTABLESREQUEST_H_
-#define ALIBABACLOUD_DRDS_MODEL_DESCRIBERECYCLEBINTABLESREQUEST_H_
+#ifndef ALIBABACLOUD_CCC_MODEL_GETINSTANCETRENDINGREPORTREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_GETINSTANCETRENDINGREPORTREQUEST_H_
 
 #include <string>
 #include <vector>
 #include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/drds/DrdsExport.h>
+#include <alibabacloud/ccc/CCCExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Drds
+	namespace CCC
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DRDS_EXPORT DescribeRecycleBinTablesRequest : public RpcServiceRequest
+			class ALIBABACLOUD_CCC_EXPORT GetInstanceTrendingReportRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeRecycleBinTablesRequest();
-				~DescribeRecycleBinTablesRequest();
+				GetInstanceTrendingReportRequest();
+				~GetInstanceTrendingReportRequest();
 
-				std::string getDrdsInstanceId()const;
-				void setDrdsInstanceId(const std::string& drdsInstanceId);
-				std::string getDbName()const;
-				void setDbName(const std::string& dbName);
-				std::string getRegionId()const;
-				void setRegionId(const std::string& regionId);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
 
             private:
-				std::string drdsInstanceId_;
-				std::string dbName_;
-				std::string regionId_;
+				long endTime_;
+				long startTime_;
+				std::string instanceId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DRDS_MODEL_DESCRIBERECYCLEBINTABLESREQUEST_H_
+#endif // !ALIBABACLOUD_CCC_MODEL_GETINSTANCETRENDINGREPORTREQUEST_H_

ccc/include/alibabacloud/ccc/model/GetInstanceTrendingReportResult.h

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CCC_MODEL_GETINSTANCETRENDINGREPORTRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_GETINSTANCETRENDINGREPORTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT GetInstanceTrendingReportResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct InboundItem
+					{
+						long callsAbandonedInRinging;
+						long totalCalls;
+						long callsAbandonedInQueue;
+						long callsQueued;
+						long callsHandled;
+						long callsAbandonedInIVR;
+						long statsTime;
+					};
+					struct OutboundItem
+					{
+						long callsAnswered;
+						long totalCalls;
+						long statsTime;
+					};
+					std::vector<OutboundItem> outbound;
+					std::vector<InboundItem> inbound;
+				};
+
+
+				GetInstanceTrendingReportResult();
+				explicit GetInstanceTrendingReportResult(const std::string &payload);
+				~GetInstanceTrendingReportResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_GETINSTANCETRENDINGREPORTRESULT_H_

ccc/include/alibabacloud/ccc/model/GetRealtimeInstanceStatesRequest.h

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

ccc/include/alibabacloud/ccc/model/GetRealtimeInstanceStatesResult.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_CCC_MODEL_GETREALTIMEINSTANCESTATESRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_GETREALTIMEINSTANCESTATESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT GetRealtimeInstanceStatesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					long breakingAgents;
+					long talkingAgents;
+					std::string instanceId;
+					long loggedInAgents;
+					long readyAgents;
+					long waitingCalls;
+					long longestCall;
+					long interactiveCalls;
+					long totalAgents;
+					long workingAgents;
+				};
+
+
+				GetRealtimeInstanceStatesResult();
+				explicit GetRealtimeInstanceStatesResult(const std::string &payload);
+				~GetRealtimeInstanceStatesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_GETREALTIMEINSTANCESTATESRESULT_H_

ccc/include/alibabacloud/ccc/model/ListAgentStateLogsRequest.h

@@ -14,41 +14,44 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DRDS_MODEL_DESCRIBERDSDRDSDBREQUEST_H_
-#define ALIBABACLOUD_DRDS_MODEL_DESCRIBERDSDRDSDBREQUEST_H_
+#ifndef ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSREQUEST_H_
 
 #include <string>
 #include <vector>
 #include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/drds/DrdsExport.h>
+#include <alibabacloud/ccc/CCCExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Drds
+	namespace CCC
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DRDS_EXPORT DescribeRdsDrdsDBRequest : public RpcServiceRequest
+			class ALIBABACLOUD_CCC_EXPORT ListAgentStateLogsRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeRdsDrdsDBRequest();
-				~DescribeRdsDrdsDBRequest();
+				ListAgentStateLogsRequest();
+				~ListAgentStateLogsRequest();
 
-				std::vector<std::string> getRdsInstanceId()const;
-				void setRdsInstanceId(const std::vector<std::string>& rdsInstanceId);
-				std::string getDrdsInstanceId()const;
-				void setDrdsInstanceId(const std::string& drdsInstanceId);
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getAgentId()const;
+				void setAgentId(const std::string& agentId);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
 
             private:
-				std::vector<std::string> rdsInstanceId_;
-				std::string drdsInstanceId_;
-				std::string accessKeyId_;
+				std::string agentId_;
+				long endTime_;
+				long startTime_;
+				std::string instanceId_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DRDS_MODEL_DESCRIBERDSDRDSDBREQUEST_H_
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSREQUEST_H_

ccc/include/alibabacloud/ccc/model/ListAgentStateLogsResult.h

@@ -14,45 +14,51 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DRDS_MODEL_DESCRIBERDSDRDSDBRESULT_H_
-#define ALIBABACLOUD_DRDS_MODEL_DESCRIBERDSDRDSDBRESULT_H_
+#ifndef ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSRESULT_H_
 
 #include <string>
 #include <vector>
 #include <utility>
 #include <alibabacloud/core/ServiceResult.h>
-#include <alibabacloud/drds/DrdsExport.h>
+#include <alibabacloud/ccc/CCCExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Drds
+	namespace CCC
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DRDS_EXPORT DescribeRdsDrdsDBResult : public ServiceResult
+			class ALIBABACLOUD_CCC_EXPORT ListAgentStateLogsResult : public ServiceResult
 			{
 			public:
-				struct RdsDrdsDb
+				struct DataItem
 				{
-					std::vector<std::string> dBList;
-					std::string rdsId;
+					std::string state;
+					long startTime;
+					std::string stateCode;
+					long duration;
 				};
 
 
-				DescribeRdsDrdsDBResult();
-				explicit DescribeRdsDrdsDBResult(const std::string &payload);
-				~DescribeRdsDrdsDBResult();
-				std::vector<RdsDrdsDb> getRdsDrdsDbs()const;
-				bool getSuccess()const;
+				ListAgentStateLogsResult();
+				explicit ListAgentStateLogsResult(const std::string &payload);
+				~ListAgentStateLogsResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<DataItem> getData()const;
+				std::string getCode()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
-				std::vector<RdsDrdsDb> rdsDrdsDbs_;
-				bool success_;
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<DataItem> data_;
+				std::string code_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DRDS_MODEL_DESCRIBERDSDRDSDBRESULT_H_
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTAGENTSTATELOGSRESULT_H_

ccc/include/alibabacloud/ccc/model/ListCallDetailRecordsRequest.h

@@ -45,16 +45,18 @@ namespace AlibabaCloud
 				void setPageNumber(int pageNumber);
 				std::string getCalledNumber()const;
 				void setCalledNumber(const std::string& calledNumber);
+				std::string getSatisfactionList()const;
+				void setSatisfactionList(const std::string& satisfactionList);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
 				std::string getSortOrder()const;
 				void setSortOrder(const std::string& sortOrder);
-				bool getWithRecording()const;
-				void setWithRecording(bool withRecording);
 				std::string getAgentId()const;
 				void setAgentId(const std::string& agentId);
 				std::string getContactType()const;
 				void setContactType(const std::string& contactType);
+				std::string getSatisfactionSurveyChannel()const;
+				void setSatisfactionSurveyChannel(const std::string& satisfactionSurveyChannel);
 				long getEndTime()const;
 				void setEndTime(long endTime);
 				std::string getCallingNumber()const;
@@ -72,11 +74,12 @@ namespace AlibabaCloud
 				long startTime_;
 				int pageNumber_;
 				std::string calledNumber_;
+				std::string satisfactionList_;
 				int pageSize_;
 				std::string sortOrder_;
-				bool withRecording_;
 				std::string agentId_;
 				std::string contactType_;
+				std::string satisfactionSurveyChannel_;
 				long endTime_;
 				std::string callingNumber_;
 				std::string contactDisposition_;

ccc/include/alibabacloud/ccc/model/ListCallDetailRecordsResult.h

@@ -41,12 +41,18 @@ namespace AlibabaCloud
 						std::string contactType;
 						std::string contactDisposition;
 						std::string instanceId;
+						std::string releaseInitiator;
+						int satisfaction;
 						long startTime;
 						std::string contactId;
 						std::string callDuration;
 						std::string callingNumber;
+						bool recordingReady;
+						long releaseTime;
 						std::string skillGroupNames;
+						std::string satisfactionSurveyChannel;
 						std::string agentIds;
+						bool satisfactionSurveyOffered;
 						long establishedTime;
 						std::string agentNames;
 					};

ccc/include/alibabacloud/ccc/model/ListHistoricalAgentReportResult.h

@@ -39,9 +39,9 @@ namespace AlibabaCloud
 						struct Inbound
 						{
 							long callsConsulted;
-							float serviceLevel20;
 							long totalWorkTime;
 							long totalHoldTime;
+							float averageHoldTime;
 							long satisfactionSurveysOffered;
 							long callsOffered;
 							long maxRingTime;
@@ -51,20 +51,24 @@ namespace AlibabaCloud
 							long satisfactionSurveysResponded;
 							long totalRingTime;
 							float handleRate;
+							long callsTransferred;
 							float averageRingTime;
 							long totalTalkTime;
-							long callsTransfered;
 							long maxTalkTime;
 							float averageWorkTime;
 							long maxWorkTime;
 							float averageTalkTime;
+							long maxHoldTime;
 						};
 						struct Outbound
 						{
 							long totalDialingTime;
 							long totalWorkTime;
 							long totalHoldTime;
+							float averageHoldTime;
+							long callsDialedSuccess;
 							long satisfactionSurveysOffered;
+							long callsHold;
 							float satisfactionIndex;
 							long satisfactionSurveysResponded;
 							float averageDialingTime;
@@ -77,6 +81,7 @@ namespace AlibabaCloud
 							long maxWorkTime;
 							float answerRate;
 							float averageTalkTime;
+							long maxHoldTime;
 						};
 						struct Overall
 						{

ccc/include/alibabacloud/ccc/model/ListHistoricalSkillGroupReportRequest.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_CCC_MODEL_LISTHISTORICALSKILLGROUPREPORTREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTHISTORICALSKILLGROUPREPORTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT ListHistoricalSkillGroupReportRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListHistoricalSkillGroupReportRequest();
+				~ListHistoricalSkillGroupReportRequest();
+
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getSkillGroupIdList()const;
+				void setSkillGroupIdList(const std::string& skillGroupIdList);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+
+            private:
+				long endTime_;
+				long startTime_;
+				int pageNumber_;
+				std::string skillGroupIdList_;
+				std::string instanceId_;
+				int pageSize_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTHISTORICALSKILLGROUPREPORTREQUEST_H_

ccc/include/alibabacloud/ccc/model/ListHistoricalSkillGroupReportResult.h

@@ -0,0 +1,154 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_CCC_MODEL_LISTHISTORICALSKILLGROUPREPORTRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTHISTORICALSKILLGROUPREPORTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT ListHistoricalSkillGroupReportResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Items
+					{
+						struct Inbound
+						{
+							long callsAbandonedInQueue;
+							float serviceLevel20;
+							long totalWorkTime;
+							long callsRinged;
+							long totalHoldTime;
+							long callsAbandoned;
+							long callsOffered;
+							long maxRingTime;
+							long callsHold;
+							float satisfactionIndex;
+							long maxAbandonedInRingTime;
+							long totalRingTime;
+							float handleRate;
+							float averageAbandonedInQueueTime;
+							long callsAbandonedInRinging;
+							float averageWaitTime;
+							long totalTalkTime;
+							long totalAbandonedInRingTime;
+							long callsQueued;
+							long maxTalkTime;
+							long totalAbandonTime;
+							float averageTalkTime;
+							long callsConsulted;
+							long maxAbandonedInQueueTime;
+							long satisfactionSurveysOffered;
+							long callsHandled;
+							long maxWaitTime;
+							long satisfactionSurveysResponded;
+							long callsTransferred;
+							float averageRingTime;
+							long maxAbandonTime;
+							long totalWaitTime;
+							float averageAbandonTime;
+							float averageAbandonedInRingTime;
+							float averageWorkTime;
+							long totalAbandonedInQueueTime;
+							long maxWorkTime;
+							float abandonRate;
+						};
+						struct Outbound
+						{
+							long totalDialingTime;
+							long totalWorkTime;
+							long totalHoldTime;
+							long satisfactionSurveysOffered;
+							float satisfactionIndex;
+							long satisfactionSurveysResponded;
+							float averageDialingTime;
+							long callsAnswered;
+							long callsDialed;
+							long totalTalkTime;
+							long maxDialingTime;
+							long maxTalkTime;
+							float averageWorkTime;
+							long maxWorkTime;
+							float answerRate;
+							float averageTalkTime;
+						};
+						struct Overall
+						{
+							long totalReadyTime;
+							long totalBreakTime;
+							long totalCalls;
+							long totalWorkTime;
+							long totalHoldTime;
+							long satisfactionSurveysOffered;
+							float satisfactionIndex;
+							float averageBreakTime;
+							long satisfactionSurveysResponded;
+							long totalTalkTime;
+							float averageReadyTime;
+							long totalLoggedInTime;
+							long maxTalkTime;
+							float averageWorkTime;
+							long maxReadyTime;
+							long maxBreakTime;
+							long maxWorkTime;
+							float averageTalkTime;
+							float occupancyRate;
+						};
+						Outbound outbound;
+						Overall overall;
+						std::string skillGroupName;
+						std::string skillGroupId;
+						Inbound inbound;
+					};
+					int totalCount;
+					int pageSize;
+					int pageNumber;
+					std::vector<Items> list;
+				};
+
+
+				ListHistoricalSkillGroupReportResult();
+				explicit ListHistoricalSkillGroupReportResult(const std::string &payload);
+				~ListHistoricalSkillGroupReportResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTHISTORICALSKILLGROUPREPORTRESULT_H_

ccc/include/alibabacloud/ccc/model/ListIntervalAgentReportRequest.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_CCC_MODEL_LISTINTERVALAGENTREPORTREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTINTERVALAGENTREPORTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT ListIntervalAgentReportRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListIntervalAgentReportRequest();
+				~ListIntervalAgentReportRequest();
+
+				std::string getAgentId()const;
+				void setAgentId(const std::string& agentId);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+
+            private:
+				std::string agentId_;
+				long endTime_;
+				long startTime_;
+				std::string instanceId_;
+				std::string interval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTINTERVALAGENTREPORTREQUEST_H_

ccc/include/alibabacloud/ccc/model/ListIntervalAgentReportResult.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CCC_MODEL_LISTINTERVALAGENTREPORTRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTINTERVALAGENTREPORTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT ListIntervalAgentReportResult : public ServiceResult
+			{
+			public:
+				struct DataItem
+				{
+					struct Inbound
+					{
+						long callsConsulted;
+						long totalWorkTime;
+						long totalHoldTime;
+						long satisfactionSurveysOffered;
+						long callsOffered;
+						long maxRingTime;
+						long callsHold;
+						float satisfactionIndex;
+						long callsHandled;
+						long satisfactionSurveysResponded;
+						long totalRingTime;
+						float handleRate;
+						long callsTransferred;
+						float averageRingTime;
+						long totalTalkTime;
+						long maxTalkTime;
+						float averageWorkTime;
+						long maxWorkTime;
+						float averageTalkTime;
+					};
+					struct Outbound
+					{
+						long totalDialingTime;
+						long totalWorkTime;
+						long totalHoldTime;
+						long satisfactionSurveysOffered;
+						float satisfactionIndex;
+						long satisfactionSurveysResponded;
+						float averageDialingTime;
+						long callsAnswered;
+						long callsDialed;
+						long totalTalkTime;
+						long maxDialingTime;
+						long maxTalkTime;
+						float averageWorkTime;
+						long maxWorkTime;
+						float answerRate;
+						float averageTalkTime;
+					};
+					struct Overall
+					{
+						long totalReadyTime;
+						long lastCheckoutTime;
+						long totalBreakTime;
+						long totalCalls;
+						long totalWorkTime;
+						long totalHoldTime;
+						long satisfactionSurveysOffered;
+						float satisfactionIndex;
+						float averageBreakTime;
+						long firstCheckInTime;
+						long satisfactionSurveysResponded;
+						long totalTalkTime;
+						float averageReadyTime;
+						long totalLoggedInTime;
+						long maxTalkTime;
+						float averageWorkTime;
+						long maxReadyTime;
+						long maxBreakTime;
+						long maxWorkTime;
+						float averageTalkTime;
+						float occupancyRate;
+					};
+					Outbound outbound;
+					Overall overall;
+					Inbound inbound;
+					long statsTime;
+				};
+
+
+				ListIntervalAgentReportResult();
+				explicit ListIntervalAgentReportResult(const std::string &payload);
+				~ListIntervalAgentReportResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<DataItem> getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<DataItem> data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTINTERVALAGENTREPORTRESULT_H_

ccc/include/alibabacloud/ccc/model/ListIntervalInstanceReportRequest.h

@@ -14,41 +14,44 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DRDS_MODEL_ENABLEINSTANCEIPV6ADDRESSREQUEST_H_
-#define ALIBABACLOUD_DRDS_MODEL_ENABLEINSTANCEIPV6ADDRESSREQUEST_H_
+#ifndef ALIBABACLOUD_CCC_MODEL_LISTINTERVALINSTANCEREPORTREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTINTERVALINSTANCEREPORTREQUEST_H_
 
 #include <string>
 #include <vector>
 #include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/drds/DrdsExport.h>
+#include <alibabacloud/ccc/CCCExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Drds
+	namespace CCC
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DRDS_EXPORT EnableInstanceIpv6AddressRequest : public RpcServiceRequest
+			class ALIBABACLOUD_CCC_EXPORT ListIntervalInstanceReportRequest : public RpcServiceRequest
 			{
 
 			public:
-				EnableInstanceIpv6AddressRequest();
-				~EnableInstanceIpv6AddressRequest();
+				ListIntervalInstanceReportRequest();
+				~ListIntervalInstanceReportRequest();
 
-				std::string getDrdsPassword()const;
-				void setDrdsPassword(const std::string& drdsPassword);
-				std::string getDrdsInstanceId()const;
-				void setDrdsInstanceId(const std::string& drdsInstanceId);
-				std::string getRegionId()const;
-				void setRegionId(const std::string& regionId);
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
 
             private:
-				std::string drdsPassword_;
-				std::string drdsInstanceId_;
-				std::string regionId_;
+				long endTime_;
+				long startTime_;
+				std::string instanceId_;
+				std::string interval_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DRDS_MODEL_ENABLEINSTANCEIPV6ADDRESSREQUEST_H_
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTINTERVALINSTANCEREPORTREQUEST_H_

ccc/include/alibabacloud/ccc/model/ListIntervalInstanceReportResult.h

@@ -0,0 +1,155 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_CCC_MODEL_LISTINTERVALINSTANCEREPORTRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTINTERVALINSTANCEREPORTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT ListIntervalInstanceReportResult : public ServiceResult
+			{
+			public:
+				struct DataItem
+				{
+					struct Inbound
+					{
+						long callsAbandonedInQueue;
+						float serviceLevel20;
+						long totalWorkTime;
+						long callsRinged;
+						long totalHoldTime;
+						float averageHoldTime;
+						long maxAbandonedInIVRTime;
+						long callsAbandoned;
+						long callsOffered;
+						long maxRingTime;
+						long callsHold;
+						float satisfactionIndex;
+						long maxAbandonedInRingTime;
+						long totalRingTime;
+						float handleRate;
+						float averageAbandonedInQueueTime;
+						long callsAbandonedInRinging;
+						long totalAbandonedInIVRTime;
+						float averageWaitTime;
+						long totalTalkTime;
+						long totalAbandonedInRingTime;
+						long callsQueued;
+						long maxTalkTime;
+						float averageAbandonedInIVRTime;
+						long totalAbandonTime;
+						float averageTalkTime;
+						long maxHoldTime;
+						long callsAbandonedInIVR;
+						long callsConsulted;
+						long maxAbandonedInQueueTime;
+						long satisfactionSurveysOffered;
+						long callsHandled;
+						long maxWaitTime;
+						long satisfactionSurveysResponded;
+						long callsTransferred;
+						float averageRingTime;
+						long maxAbandonTime;
+						long totalWaitTime;
+						float averageAbandonTime;
+						float averageAbandonedInRingTime;
+						float averageWorkTime;
+						long totalAbandonedInQueueTime;
+						float abandonedRate;
+						long maxWorkTime;
+					};
+					struct Outbound
+					{
+						long totalDialingTime;
+						long totalWorkTime;
+						long totalHoldTime;
+						long callsDialedSuccess;
+						long satisfactionSurveysOffered;
+						float satisfactionIndex;
+						long satisfactionSurveysResponded;
+						float averageDialingTime;
+						long callsAnswered;
+						long callsDialed;
+						long totalTalkTime;
+						long maxDialingTime;
+						long maxTalkTime;
+						float averageWorkTime;
+						long maxWorkTime;
+						float answerRate;
+						float averageTalkTime;
+					};
+					struct Overall
+					{
+						long totalReadyTime;
+						long totalBreakTime;
+						long totalCalls;
+						long totalWorkTime;
+						long totalHoldTime;
+						float averageHoldTime;
+						long satisfactionSurveysOffered;
+						float satisfactionIndex;
+						float averageBreakTime;
+						long satisfactionSurveysResponded;
+						long totalTalkTime;
+						float averageReadyTime;
+						long totalLoggedInTime;
+						long maxTalkTime;
+						float averageWorkTime;
+						long maxReadyTime;
+						long maxBreakTime;
+						long maxWorkTime;
+						float averageTalkTime;
+						long maxHoldTime;
+						float occupancyRate;
+					};
+					Outbound outbound;
+					Overall overall;
+					Inbound inbound;
+					long statsTime;
+				};
+
+
+				ListIntervalInstanceReportResult();
+				explicit ListIntervalInstanceReportResult(const std::string &payload);
+				~ListIntervalInstanceReportResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<DataItem> getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<DataItem> data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTINTERVALINSTANCEREPORTRESULT_H_

ccc/include/alibabacloud/ccc/model/ListIntervalSkillGroupReportRequest.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_CCC_MODEL_LISTINTERVALSKILLGROUPREPORTREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTINTERVALSKILLGROUPREPORTREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT ListIntervalSkillGroupReportRequest : public RpcServiceRequest
+			{
+
+			public:
+				ListIntervalSkillGroupReportRequest();
+				~ListIntervalSkillGroupReportRequest();
+
+				long getEndTime()const;
+				void setEndTime(long endTime);
+				long getStartTime()const;
+				void setStartTime(long startTime);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
+				std::string getSkillGroupId()const;
+				void setSkillGroupId(const std::string& skillGroupId);
+				std::string getInterval()const;
+				void setInterval(const std::string& interval);
+
+            private:
+				long endTime_;
+				long startTime_;
+				std::string instanceId_;
+				std::string skillGroupId_;
+				std::string interval_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTINTERVALSKILLGROUPREPORTREQUEST_H_

ccc/include/alibabacloud/ccc/model/ListIntervalSkillGroupReportResult.h

@@ -0,0 +1,146 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_CCC_MODEL_LISTINTERVALSKILLGROUPREPORTRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTINTERVALSKILLGROUPREPORTRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT ListIntervalSkillGroupReportResult : public ServiceResult
+			{
+			public:
+				struct DataItem
+				{
+					struct Inbound
+					{
+						long callsAbandonedInQueue;
+						float serviceLevel20;
+						long totalWorkTime;
+						long callsRinged;
+						long totalHoldTime;
+						long callsAbandoned;
+						long callsOffered;
+						long maxRingTime;
+						long callsHold;
+						float satisfactionIndex;
+						long maxAbandonedInRingTime;
+						long totalRingTime;
+						float handleRate;
+						float averageAbandonedInQueueTime;
+						long callsAbandonedInRinging;
+						float averageWaitTime;
+						long totalTalkTime;
+						long totalAbandonedInRingTime;
+						long callsQueued;
+						long maxTalkTime;
+						long totalAbandonTime;
+						float averageTalkTime;
+						long callsConsulted;
+						long maxAbandonedInQueueTime;
+						long satisfactionSurveysOffered;
+						long callsHandled;
+						long maxWaitTime;
+						long satisfactionSurveysResponded;
+						long callsTransferred;
+						float averageRingTime;
+						long maxAbandonTime;
+						long totalWaitTime;
+						float averageAbandonTime;
+						float averageAbandonedInRingTime;
+						float averageWorkTime;
+						long totalAbandonedInQueueTime;
+						long maxWorkTime;
+						float abandonRate;
+					};
+					struct Outbound
+					{
+						long totalDialingTime;
+						long totalWorkTime;
+						long totalHoldTime;
+						long satisfactionSurveysOffered;
+						float satisfactionIndex;
+						long satisfactionSurveysResponded;
+						float averageDialingTime;
+						long callsAnswered;
+						long callsDialed;
+						long totalTalkTime;
+						long maxDialingTime;
+						long maxTalkTime;
+						float averageWorkTime;
+						long maxWorkTime;
+						float answerRate;
+						float averageTalkTime;
+					};
+					struct Overall
+					{
+						long totalReadyTime;
+						long totalBreakTime;
+						long totalCalls;
+						long totalWorkTime;
+						long totalHoldTime;
+						long satisfactionSurveysOffered;
+						float satisfactionIndex;
+						float averageBreakTime;
+						long satisfactionSurveysResponded;
+						long totalTalkTime;
+						float averageReadyTime;
+						long totalLoggedInTime;
+						long maxTalkTime;
+						float averageWorkTime;
+						long maxReadyTime;
+						long maxBreakTime;
+						long maxWorkTime;
+						float averageTalkTime;
+						float occupancyRate;
+					};
+					Outbound outbound;
+					Overall overall;
+					Inbound inbound;
+					long statsTime;
+				};
+
+
+				ListIntervalSkillGroupReportResult();
+				explicit ListIntervalSkillGroupReportResult(const std::string &payload);
+				~ListIntervalSkillGroupReportResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				std::vector<DataItem> getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				std::vector<DataItem> data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTINTERVALSKILLGROUPREPORTRESULT_H_

ccc/include/alibabacloud/ccc/model/ListIvrTrackingDetailsRequest.h

@@ -14,38 +14,44 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DRDS_MODEL_DESCRIBEEVALUATETASKSREQUEST_H_
-#define ALIBABACLOUD_DRDS_MODEL_DESCRIBEEVALUATETASKSREQUEST_H_
+#ifndef ALIBABACLOUD_CCC_MODEL_LISTIVRTRACKINGDETAILSREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTIVRTRACKINGDETAILSREQUEST_H_
 
 #include <string>
 #include <vector>
 #include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/drds/DrdsExport.h>
+#include <alibabacloud/ccc/CCCExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Drds
+	namespace CCC
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DRDS_EXPORT DescribeEvaluateTasksRequest : public RpcServiceRequest
+			class ALIBABACLOUD_CCC_EXPORT ListIvrTrackingDetailsRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeEvaluateTasksRequest();
-				~DescribeEvaluateTasksRequest();
+				ListIvrTrackingDetailsRequest();
+				~ListIvrTrackingDetailsRequest();
 
+				std::string getContactId()const;
+				void setContactId(const std::string& contactId);
 				int getPageNumber()const;
 				void setPageNumber(int pageNumber);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
 
             private:
+				std::string contactId_;
 				int pageNumber_;
+				std::string instanceId_;
 				int pageSize_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DRDS_MODEL_DESCRIBEEVALUATETASKSREQUEST_H_
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTIVRTRACKINGDETAILSREQUEST_H_

ccc/include/alibabacloud/ccc/model/ListIvrTrackingDetailsResult.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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_CCC_MODEL_LISTIVRTRACKINGDETAILSRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTIVRTRACKINGDETAILSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT ListIvrTrackingDetailsResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct IvrTracking
+					{
+						std::string callee;
+						std::string instance;
+						std::string nodeName;
+						long enterTime;
+						std::string contactId;
+						std::string nodeExitCode;
+						std::string channelId;
+						std::string channelVariables;
+						std::string flowId;
+						long leaveTime;
+						std::string nodeProperties;
+						std::string caller;
+						std::string flowName;
+						std::string nodeType;
+						std::string nodeId;
+						std::string nodeVariables;
+					};
+					int totalCount;
+					int pageSize;
+					int pageNumber;
+					std::vector<IvrTracking> list;
+				};
+
+
+				ListIvrTrackingDetailsResult();
+				explicit ListIvrTrackingDetailsResult(const std::string &payload);
+				~ListIvrTrackingDetailsResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTIVRTRACKINGDETAILSRESULT_H_

ccc/include/alibabacloud/ccc/model/ListRealtimeSkillGroupStatesRequest.h

@@ -14,41 +14,44 @@
  * limitations under the License.
  */
 
-#ifndef ALIBABACLOUD_DRDS_MODEL_DESCRIBEDATAIMPORTTASKSREQUEST_H_
-#define ALIBABACLOUD_DRDS_MODEL_DESCRIBEDATAIMPORTTASKSREQUEST_H_
+#ifndef ALIBABACLOUD_CCC_MODEL_LISTREALTIMESKILLGROUPSTATESREQUEST_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTREALTIMESKILLGROUPSTATESREQUEST_H_
 
 #include <string>
 #include <vector>
 #include <alibabacloud/core/RpcServiceRequest.h>
-#include <alibabacloud/drds/DrdsExport.h>
+#include <alibabacloud/ccc/CCCExport.h>
 
 namespace AlibabaCloud
 {
-	namespace Drds
+	namespace CCC
 	{
 		namespace Model
 		{
-			class ALIBABACLOUD_DRDS_EXPORT DescribeDataImportTasksRequest : public RpcServiceRequest
+			class ALIBABACLOUD_CCC_EXPORT ListRealtimeSkillGroupStatesRequest : public RpcServiceRequest
 			{
 
 			public:
-				DescribeDataImportTasksRequest();
-				~DescribeDataImportTasksRequest();
+				ListRealtimeSkillGroupStatesRequest();
+				~ListRealtimeSkillGroupStatesRequest();
 
 				int getPageNumber()const;
 				void setPageNumber(int pageNumber);
-				std::string getAccessKeyId()const;
-				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getSkillGroupIdList()const;
+				void setSkillGroupIdList(const std::string& skillGroupIdList);
+				std::string getInstanceId()const;
+				void setInstanceId(const std::string& instanceId);
 				int getPageSize()const;
 				void setPageSize(int pageSize);
 
             private:
 				int pageNumber_;
-				std::string accessKeyId_;
+				std::string skillGroupIdList_;
+				std::string instanceId_;
 				int pageSize_;
 
 			};
 		}
 	}
 }
-#endif // !ALIBABACLOUD_DRDS_MODEL_DESCRIBEDATAIMPORTTASKSREQUEST_H_
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTREALTIMESKILLGROUPSTATESREQUEST_H_

ccc/include/alibabacloud/ccc/model/ListRealtimeSkillGroupStatesResult.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_CCC_MODEL_LISTREALTIMESKILLGROUPSTATESRESULT_H_
+#define ALIBABACLOUD_CCC_MODEL_LISTREALTIMESKILLGROUPSTATESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/ccc/CCCExport.h>
+
+namespace AlibabaCloud
+{
+	namespace CCC
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CCC_EXPORT ListRealtimeSkillGroupStatesResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct SkillGroupState
+					{
+						long breakingAgents;
+						long talkingAgents;
+						long longestWaitingTime;
+						std::string skillGroupName;
+						std::string instanceId;
+						long loggedInAgents;
+						long readyAgents;
+						long waitingCalls;
+						std::string skillGroupId;
+						long workingAgents;
+					};
+					int totalCount;
+					int pageSize;
+					int pageNumber;
+					std::vector<SkillGroupState> list;
+				};
+
+
+				ListRealtimeSkillGroupStatesResult();
+				explicit ListRealtimeSkillGroupStatesResult(const std::string &payload);
+				~ListRealtimeSkillGroupStatesResult();
+				std::string getMessage()const;
+				int getHttpStatusCode()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				int httpStatusCode_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CCC_MODEL_LISTREALTIMESKILLGROUPSTATESRESULT_H_

ccc/include/alibabacloud/ccc/model/ListUsersResult.h

@@ -55,6 +55,7 @@ namespace AlibabaCloud
 						std::string email;
 						std::string userId;
 						std::vector<UserDetail::UserSkillLevel> skillLevelList;
+						bool primaryAccount;
 						std::string displayName;
 						std::vector<UserDetail::PhoneNumber> personalOutboundNumberList;
 						std::string mobile;

ccc/src/CCCClient.cc

@@ -663,6 +663,114 @@ CCCClient::DeleteSkillGroupOutcomeCallable CCCClient::deleteSkillGroupCallable(c
 	return task->get_future();
 }
 
+CCCClient::GetCallDetailRecordOutcome CCCClient::getCallDetailRecord(const GetCallDetailRecordRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetCallDetailRecordOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetCallDetailRecordOutcome(GetCallDetailRecordResult(outcome.result()));
+	else
+		return GetCallDetailRecordOutcome(outcome.error());
+}
+
+void CCCClient::getCallDetailRecordAsync(const GetCallDetailRecordRequest& request, const GetCallDetailRecordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getCallDetailRecord(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::GetCallDetailRecordOutcomeCallable CCCClient::getCallDetailRecordCallable(const GetCallDetailRecordRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetCallDetailRecordOutcome()>>(
+			[this, request]()
+			{
+			return this->getCallDetailRecord(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CCCClient::GetHistoricalCallerReportOutcome CCCClient::getHistoricalCallerReport(const GetHistoricalCallerReportRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetHistoricalCallerReportOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetHistoricalCallerReportOutcome(GetHistoricalCallerReportResult(outcome.result()));
+	else
+		return GetHistoricalCallerReportOutcome(outcome.error());
+}
+
+void CCCClient::getHistoricalCallerReportAsync(const GetHistoricalCallerReportRequest& request, const GetHistoricalCallerReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getHistoricalCallerReport(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::GetHistoricalCallerReportOutcomeCallable CCCClient::getHistoricalCallerReportCallable(const GetHistoricalCallerReportRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetHistoricalCallerReportOutcome()>>(
+			[this, request]()
+			{
+			return this->getHistoricalCallerReport(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CCCClient::GetHistoricalInstanceReportOutcome CCCClient::getHistoricalInstanceReport(const GetHistoricalInstanceReportRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetHistoricalInstanceReportOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetHistoricalInstanceReportOutcome(GetHistoricalInstanceReportResult(outcome.result()));
+	else
+		return GetHistoricalInstanceReportOutcome(outcome.error());
+}
+
+void CCCClient::getHistoricalInstanceReportAsync(const GetHistoricalInstanceReportRequest& request, const GetHistoricalInstanceReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getHistoricalInstanceReport(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::GetHistoricalInstanceReportOutcomeCallable CCCClient::getHistoricalInstanceReportCallable(const GetHistoricalInstanceReportRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetHistoricalInstanceReportOutcome()>>(
+			[this, request]()
+			{
+			return this->getHistoricalInstanceReport(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CCCClient::GetInstanceOutcome CCCClient::getInstance(const GetInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -699,6 +807,42 @@ CCCClient::GetInstanceOutcomeCallable CCCClient::getInstanceCallable(const GetIn
 	return task->get_future();
 }
 
+CCCClient::GetInstanceTrendingReportOutcome CCCClient::getInstanceTrendingReport(const GetInstanceTrendingReportRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetInstanceTrendingReportOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetInstanceTrendingReportOutcome(GetInstanceTrendingReportResult(outcome.result()));
+	else
+		return GetInstanceTrendingReportOutcome(outcome.error());
+}
+
+void CCCClient::getInstanceTrendingReportAsync(const GetInstanceTrendingReportRequest& request, const GetInstanceTrendingReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getInstanceTrendingReport(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::GetInstanceTrendingReportOutcomeCallable CCCClient::getInstanceTrendingReportCallable(const GetInstanceTrendingReportRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetInstanceTrendingReportOutcome()>>(
+			[this, request]()
+			{
+			return this->getInstanceTrendingReport(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CCCClient::GetLoginDetailsOutcome CCCClient::getLoginDetails(const GetLoginDetailsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -843,6 +987,42 @@ CCCClient::GetNumberLocationOutcomeCallable CCCClient::getNumberLocationCallable
 	return task->get_future();
 }
 
+CCCClient::GetRealtimeInstanceStatesOutcome CCCClient::getRealtimeInstanceStates(const GetRealtimeInstanceStatesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetRealtimeInstanceStatesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetRealtimeInstanceStatesOutcome(GetRealtimeInstanceStatesResult(outcome.result()));
+	else
+		return GetRealtimeInstanceStatesOutcome(outcome.error());
+}
+
+void CCCClient::getRealtimeInstanceStatesAsync(const GetRealtimeInstanceStatesRequest& request, const GetRealtimeInstanceStatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getRealtimeInstanceStates(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::GetRealtimeInstanceStatesOutcomeCallable CCCClient::getRealtimeInstanceStatesCallable(const GetRealtimeInstanceStatesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetRealtimeInstanceStatesOutcome()>>(
+			[this, request]()
+			{
+			return this->getRealtimeInstanceStates(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CCCClient::GetTurnCredentialsOutcome CCCClient::getTurnCredentials(const GetTurnCredentialsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1131,6 +1311,42 @@ CCCClient::LaunchSurveyOutcomeCallable CCCClient::launchSurveyCallable(const Lau
 	return task->get_future();
 }
 
+CCCClient::ListAgentStateLogsOutcome CCCClient::listAgentStateLogs(const ListAgentStateLogsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListAgentStateLogsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListAgentStateLogsOutcome(ListAgentStateLogsResult(outcome.result()));
+	else
+		return ListAgentStateLogsOutcome(outcome.error());
+}
+
+void CCCClient::listAgentStateLogsAsync(const ListAgentStateLogsRequest& request, const ListAgentStateLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listAgentStateLogs(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::ListAgentStateLogsOutcomeCallable CCCClient::listAgentStateLogsCallable(const ListAgentStateLogsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListAgentStateLogsOutcome()>>(
+			[this, request]()
+			{
+			return this->listAgentStateLogs(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CCCClient::ListBriefSkillGroupsOutcome CCCClient::listBriefSkillGroups(const ListBriefSkillGroupsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1347,6 +1563,42 @@ CCCClient::ListHistoricalAgentReportOutcomeCallable CCCClient::listHistoricalAge
 	return task->get_future();
 }
 
+CCCClient::ListHistoricalSkillGroupReportOutcome CCCClient::listHistoricalSkillGroupReport(const ListHistoricalSkillGroupReportRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListHistoricalSkillGroupReportOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListHistoricalSkillGroupReportOutcome(ListHistoricalSkillGroupReportResult(outcome.result()));
+	else
+		return ListHistoricalSkillGroupReportOutcome(outcome.error());
+}
+
+void CCCClient::listHistoricalSkillGroupReportAsync(const ListHistoricalSkillGroupReportRequest& request, const ListHistoricalSkillGroupReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listHistoricalSkillGroupReport(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::ListHistoricalSkillGroupReportOutcomeCallable CCCClient::listHistoricalSkillGroupReportCallable(const ListHistoricalSkillGroupReportRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListHistoricalSkillGroupReportOutcome()>>(
+			[this, request]()
+			{
+			return this->listHistoricalSkillGroupReport(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CCCClient::ListInstancesOfUserOutcome CCCClient::listInstancesOfUser(const ListInstancesOfUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1383,6 +1635,150 @@ CCCClient::ListInstancesOfUserOutcomeCallable CCCClient::listInstancesOfUserCall
 	return task->get_future();
 }
 
+CCCClient::ListIntervalAgentReportOutcome CCCClient::listIntervalAgentReport(const ListIntervalAgentReportRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListIntervalAgentReportOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListIntervalAgentReportOutcome(ListIntervalAgentReportResult(outcome.result()));
+	else
+		return ListIntervalAgentReportOutcome(outcome.error());
+}
+
+void CCCClient::listIntervalAgentReportAsync(const ListIntervalAgentReportRequest& request, const ListIntervalAgentReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listIntervalAgentReport(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::ListIntervalAgentReportOutcomeCallable CCCClient::listIntervalAgentReportCallable(const ListIntervalAgentReportRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListIntervalAgentReportOutcome()>>(
+			[this, request]()
+			{
+			return this->listIntervalAgentReport(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CCCClient::ListIntervalInstanceReportOutcome CCCClient::listIntervalInstanceReport(const ListIntervalInstanceReportRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListIntervalInstanceReportOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListIntervalInstanceReportOutcome(ListIntervalInstanceReportResult(outcome.result()));
+	else
+		return ListIntervalInstanceReportOutcome(outcome.error());
+}
+
+void CCCClient::listIntervalInstanceReportAsync(const ListIntervalInstanceReportRequest& request, const ListIntervalInstanceReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listIntervalInstanceReport(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::ListIntervalInstanceReportOutcomeCallable CCCClient::listIntervalInstanceReportCallable(const ListIntervalInstanceReportRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListIntervalInstanceReportOutcome()>>(
+			[this, request]()
+			{
+			return this->listIntervalInstanceReport(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CCCClient::ListIntervalSkillGroupReportOutcome CCCClient::listIntervalSkillGroupReport(const ListIntervalSkillGroupReportRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListIntervalSkillGroupReportOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListIntervalSkillGroupReportOutcome(ListIntervalSkillGroupReportResult(outcome.result()));
+	else
+		return ListIntervalSkillGroupReportOutcome(outcome.error());
+}
+
+void CCCClient::listIntervalSkillGroupReportAsync(const ListIntervalSkillGroupReportRequest& request, const ListIntervalSkillGroupReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listIntervalSkillGroupReport(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::ListIntervalSkillGroupReportOutcomeCallable CCCClient::listIntervalSkillGroupReportCallable(const ListIntervalSkillGroupReportRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListIntervalSkillGroupReportOutcome()>>(
+			[this, request]()
+			{
+			return this->listIntervalSkillGroupReport(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+CCCClient::ListIvrTrackingDetailsOutcome CCCClient::listIvrTrackingDetails(const ListIvrTrackingDetailsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListIvrTrackingDetailsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListIvrTrackingDetailsOutcome(ListIvrTrackingDetailsResult(outcome.result()));
+	else
+		return ListIvrTrackingDetailsOutcome(outcome.error());
+}
+
+void CCCClient::listIvrTrackingDetailsAsync(const ListIvrTrackingDetailsRequest& request, const ListIvrTrackingDetailsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listIvrTrackingDetails(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::ListIvrTrackingDetailsOutcomeCallable CCCClient::listIvrTrackingDetailsCallable(const ListIvrTrackingDetailsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListIvrTrackingDetailsOutcome()>>(
+			[this, request]()
+			{
+			return this->listIvrTrackingDetails(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CCCClient::ListOutboundNumbersOfUserOutcome CCCClient::listOutboundNumbersOfUser(const ListOutboundNumbersOfUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1599,6 +1995,42 @@ CCCClient::ListRealtimeAgentStatesOutcomeCallable CCCClient::listRealtimeAgentSt
 	return task->get_future();
 }
 
+CCCClient::ListRealtimeSkillGroupStatesOutcome CCCClient::listRealtimeSkillGroupStates(const ListRealtimeSkillGroupStatesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ListRealtimeSkillGroupStatesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ListRealtimeSkillGroupStatesOutcome(ListRealtimeSkillGroupStatesResult(outcome.result()));
+	else
+		return ListRealtimeSkillGroupStatesOutcome(outcome.error());
+}
+
+void CCCClient::listRealtimeSkillGroupStatesAsync(const ListRealtimeSkillGroupStatesRequest& request, const ListRealtimeSkillGroupStatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, listRealtimeSkillGroupStates(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CCCClient::ListRealtimeSkillGroupStatesOutcomeCallable CCCClient::listRealtimeSkillGroupStatesCallable(const ListRealtimeSkillGroupStatesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ListRealtimeSkillGroupStatesOutcome()>>(
+			[this, request]()
+			{
+			return this->listRealtimeSkillGroupStates(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CCCClient::ListRecentCallDetailRecordsOutcome CCCClient::listRecentCallDetailRecords(const ListRecentCallDetailRecordsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

ccc/src/model/GetCallDetailRecordRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ccc/model/GetCallDetailRecordRequest.h>
+
+using AlibabaCloud::CCC::Model::GetCallDetailRecordRequest;
+
+GetCallDetailRecordRequest::GetCallDetailRecordRequest() :
+	RpcServiceRequest("ccc", "2020-07-01", "GetCallDetailRecord")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetCallDetailRecordRequest::~GetCallDetailRecordRequest()
+{}
+
+std::string GetCallDetailRecordRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void GetCallDetailRecordRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string GetCallDetailRecordRequest::getContactId()const
+{
+	return contactId_;
+}
+
+void GetCallDetailRecordRequest::setContactId(const std::string& contactId)
+{
+	contactId_ = contactId;
+	setParameter("ContactId", contactId);
+}
+

ccc/src/model/GetCallDetailRecordResult.cc

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ccc/model/GetCallDetailRecordResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+GetCallDetailRecordResult::GetCallDetailRecordResult() :
+	ServiceResult()
+{}
+
+GetCallDetailRecordResult::GetCallDetailRecordResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetCallDetailRecordResult::~GetCallDetailRecordResult()
+{}
+
+void GetCallDetailRecordResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["AgentIds"].isNull())
+		data_.agentIds = dataNode["AgentIds"].asString();
+	if(!dataNode["AgentNames"].isNull())
+		data_.agentNames = dataNode["AgentNames"].asString();
+	if(!dataNode["CalledNumber"].isNull())
+		data_.calledNumber = dataNode["CalledNumber"].asString();
+	if(!dataNode["CallingNumber"].isNull())
+		data_.callingNumber = dataNode["CallingNumber"].asString();
+	if(!dataNode["ContactDisposition"].isNull())
+		data_.contactDisposition = dataNode["ContactDisposition"].asString();
+	if(!dataNode["ContactId"].isNull())
+		data_.contactId = dataNode["ContactId"].asString();
+	if(!dataNode["ContactType"].isNull())
+		data_.contactType = dataNode["ContactType"].asString();
+	if(!dataNode["CallDuration"].isNull())
+		data_.callDuration = std::stol(dataNode["CallDuration"].asString());
+	if(!dataNode["EstablishedTime"].isNull())
+		data_.establishedTime = std::stol(dataNode["EstablishedTime"].asString());
+	if(!dataNode["InstanceId"].isNull())
+		data_.instanceId = dataNode["InstanceId"].asString();
+	if(!dataNode["StartTime"].isNull())
+		data_.startTime = std::stol(dataNode["StartTime"].asString());
+	if(!dataNode["ReleaseTime"].isNull())
+		data_.releaseTime = std::stol(dataNode["ReleaseTime"].asString());
+	if(!dataNode["SkillGroupIds"].isNull())
+		data_.skillGroupIds = dataNode["SkillGroupIds"].asString();
+	if(!dataNode["SkillGroupNames"].isNull())
+		data_.skillGroupNames = dataNode["SkillGroupNames"].asString();
+	if(!dataNode["SatisfactionSurveyOffered"].isNull())
+		data_.satisfactionSurveyOffered = dataNode["SatisfactionSurveyOffered"].asString() == "true";
+	if(!dataNode["Satisfaction"].isNull())
+		data_.satisfaction = std::stoi(dataNode["Satisfaction"].asString());
+	if(!dataNode["SatisfactionSurveyChannel"].isNull())
+		data_.satisfactionSurveyChannel = dataNode["SatisfactionSurveyChannel"].asString();
+	if(!dataNode["ReleaseInitiator"].isNull())
+		data_.releaseInitiator = dataNode["ReleaseInitiator"].asString();
+	if(!dataNode["RecordingReady"].isNull())
+		data_.recordingReady = dataNode["RecordingReady"].asString() == "true";
+	auto allCdrAgentEventsNode = dataNode["CdrAgentEvents"]["CdrAgentEventsItem"];
+	for (auto dataNodeCdrAgentEventsCdrAgentEventsItem : allCdrAgentEventsNode)
+	{
+		Data::CdrAgentEventsItem cdrAgentEventsItemObject;
+		if(!dataNodeCdrAgentEventsCdrAgentEventsItem["AgentId"].isNull())
+			cdrAgentEventsItemObject.agentId = dataNodeCdrAgentEventsCdrAgentEventsItem["AgentId"].asString();
+		if(!dataNodeCdrAgentEventsCdrAgentEventsItem["AgentName"].isNull())
+			cdrAgentEventsItemObject.agentName = dataNodeCdrAgentEventsCdrAgentEventsItem["AgentName"].asString();
+		if(!dataNodeCdrAgentEventsCdrAgentEventsItem["SkillGroupId"].isNull())
+			cdrAgentEventsItemObject.skillGroupId = dataNodeCdrAgentEventsCdrAgentEventsItem["SkillGroupId"].asString();
+		auto allEventSequenceNode = dataNodeCdrAgentEventsCdrAgentEventsItem["EventSequence"]["EventSequenceItem"];
+		for (auto dataNodeCdrAgentEventsCdrAgentEventsItemEventSequenceEventSequenceItem : allEventSequenceNode)
+		{
+			Data::CdrAgentEventsItem::EventSequenceItem eventSequenceObject;
+			if(!dataNodeCdrAgentEventsCdrAgentEventsItemEventSequenceEventSequenceItem["Event"].isNull())
+				eventSequenceObject.event = dataNodeCdrAgentEventsCdrAgentEventsItemEventSequenceEventSequenceItem["Event"].asString();
+			if(!dataNodeCdrAgentEventsCdrAgentEventsItemEventSequenceEventSequenceItem["EventTime"].isNull())
+				eventSequenceObject.eventTime = std::stol(dataNodeCdrAgentEventsCdrAgentEventsItemEventSequenceEventSequenceItem["EventTime"].asString());
+			cdrAgentEventsItemObject.eventSequence.push_back(eventSequenceObject);
+		}
+		data_.cdrAgentEvents.push_back(cdrAgentEventsItemObject);
+	}
+	auto allCdrIvrEventsNode = dataNode["CdrIvrEvents"]["CdrIvrEventsItem"];
+	for (auto dataNodeCdrIvrEventsCdrIvrEventsItem : allCdrIvrEventsNode)
+	{
+		Data::CdrIvrEventsItem cdrIvrEventsItemObject;
+		if(!dataNodeCdrIvrEventsCdrIvrEventsItem["FlowId"].isNull())
+			cdrIvrEventsItemObject.flowId = dataNodeCdrIvrEventsCdrIvrEventsItem["FlowId"].asString();
+		auto allEventSequence1Node = dataNodeCdrIvrEventsCdrIvrEventsItem["EventSequence"]["EventSequenceItem"];
+		for (auto dataNodeCdrIvrEventsCdrIvrEventsItemEventSequenceEventSequenceItem : allEventSequence1Node)
+		{
+			Data::CdrIvrEventsItem::EventSequenceItem2 eventSequence1Object;
+			if(!dataNodeCdrIvrEventsCdrIvrEventsItemEventSequenceEventSequenceItem["Event"].isNull())
+				eventSequence1Object.event = dataNodeCdrIvrEventsCdrIvrEventsItemEventSequenceEventSequenceItem["Event"].asString();
+			if(!dataNodeCdrIvrEventsCdrIvrEventsItemEventSequenceEventSequenceItem["EventTime"].isNull())
+				eventSequence1Object.eventTime = std::stol(dataNodeCdrIvrEventsCdrIvrEventsItemEventSequenceEventSequenceItem["EventTime"].asString());
+			cdrIvrEventsItemObject.eventSequence1.push_back(eventSequence1Object);
+		}
+		data_.cdrIvrEvents.push_back(cdrIvrEventsItemObject);
+	}
+	auto allCdrQueueEventsNode = dataNode["CdrQueueEvents"]["CdrQueueEventsItem"];
+	for (auto dataNodeCdrQueueEventsCdrQueueEventsItem : allCdrQueueEventsNode)
+	{
+		Data::CdrQueueEventsItem cdrQueueEventsItemObject;
+		if(!dataNodeCdrQueueEventsCdrQueueEventsItem["FlowId"].isNull())
+			cdrQueueEventsItemObject.flowId = dataNodeCdrQueueEventsCdrQueueEventsItem["FlowId"].asString();
+		if(!dataNodeCdrQueueEventsCdrQueueEventsItem["QueueId"].isNull())
+			cdrQueueEventsItemObject.queueId = dataNodeCdrQueueEventsCdrQueueEventsItem["QueueId"].asString();
+		if(!dataNodeCdrQueueEventsCdrQueueEventsItem["QueueName"].isNull())
+			cdrQueueEventsItemObject.queueName = dataNodeCdrQueueEventsCdrQueueEventsItem["QueueName"].asString();
+		if(!dataNodeCdrQueueEventsCdrQueueEventsItem["QueueType"].isNull())
+			cdrQueueEventsItemObject.queueType = std::stoi(dataNodeCdrQueueEventsCdrQueueEventsItem["QueueType"].asString());
+		auto allEventSequence3Node = dataNodeCdrQueueEventsCdrQueueEventsItem["EventSequence"]["EventSequenceItem"];
+		for (auto dataNodeCdrQueueEventsCdrQueueEventsItemEventSequenceEventSequenceItem : allEventSequence3Node)
+		{
+			Data::CdrQueueEventsItem::EventSequenceItem4 eventSequence3Object;
+			if(!dataNodeCdrQueueEventsCdrQueueEventsItemEventSequenceEventSequenceItem["Event"].isNull())
+				eventSequence3Object.event = dataNodeCdrQueueEventsCdrQueueEventsItemEventSequenceEventSequenceItem["Event"].asString();
+			if(!dataNodeCdrQueueEventsCdrQueueEventsItemEventSequenceEventSequenceItem["EventTime"].isNull())
+				eventSequence3Object.eventTime = std::stol(dataNodeCdrQueueEventsCdrQueueEventsItemEventSequenceEventSequenceItem["EventTime"].asString());
+			cdrQueueEventsItemObject.eventSequence3.push_back(eventSequence3Object);
+		}
+		data_.cdrQueueEvents.push_back(cdrQueueEventsItemObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string GetCallDetailRecordResult::getMessage()const
+{
+	return message_;
+}
+
+int GetCallDetailRecordResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+GetCallDetailRecordResult::Data GetCallDetailRecordResult::getData()const
+{
+	return data_;
+}
+
+std::string GetCallDetailRecordResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/GetHistoricalCallerReportRequest.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/ccc/model/GetHistoricalCallerReportRequest.h>
+
+using AlibabaCloud::CCC::Model::GetHistoricalCallerReportRequest;
+
+GetHistoricalCallerReportRequest::GetHistoricalCallerReportRequest() :
+	RpcServiceRequest("ccc", "2020-07-01", "GetHistoricalCallerReport")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetHistoricalCallerReportRequest::~GetHistoricalCallerReportRequest()
+{}
+
+long GetHistoricalCallerReportRequest::getStopTime()const
+{
+	return stopTime_;
+}
+
+void GetHistoricalCallerReportRequest::setStopTime(long stopTime)
+{
+	stopTime_ = stopTime;
+	setParameter("StopTime", std::to_string(stopTime));
+}
+
+long GetHistoricalCallerReportRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void GetHistoricalCallerReportRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", std::to_string(startTime));
+}
+
+std::string GetHistoricalCallerReportRequest::getCallingNumber()const
+{
+	return callingNumber_;
+}
+
+void GetHistoricalCallerReportRequest::setCallingNumber(const std::string& callingNumber)
+{
+	callingNumber_ = callingNumber;
+	setParameter("CallingNumber", callingNumber);
+}
+
+std::string GetHistoricalCallerReportRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void GetHistoricalCallerReportRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

ccc/src/model/GetHistoricalCallerReportResult.cc

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ccc/model/GetHistoricalCallerReportResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+GetHistoricalCallerReportResult::GetHistoricalCallerReportResult() :
+	ServiceResult()
+{}
+
+GetHistoricalCallerReportResult::GetHistoricalCallerReportResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetHistoricalCallerReportResult::~GetHistoricalCallerReportResult()
+{}
+
+void GetHistoricalCallerReportResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["LastCallingTime"].isNull())
+		data_.lastCallingTime = std::stol(dataNode["LastCallingTime"].asString());
+	if(!dataNode["TotalCalls"].isNull())
+		data_.totalCalls = std::stol(dataNode["TotalCalls"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string GetHistoricalCallerReportResult::getMessage()const
+{
+	return message_;
+}
+
+int GetHistoricalCallerReportResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+GetHistoricalCallerReportResult::Data GetHistoricalCallerReportResult::getData()const
+{
+	return data_;
+}
+
+std::string GetHistoricalCallerReportResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/GetHistoricalInstanceReportRequest.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/ccc/model/GetHistoricalInstanceReportRequest.h>
+
+using AlibabaCloud::CCC::Model::GetHistoricalInstanceReportRequest;
+
+GetHistoricalInstanceReportRequest::GetHistoricalInstanceReportRequest() :
+	RpcServiceRequest("ccc", "2020-07-01", "GetHistoricalInstanceReport")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetHistoricalInstanceReportRequest::~GetHistoricalInstanceReportRequest()
+{}
+
+long GetHistoricalInstanceReportRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void GetHistoricalInstanceReportRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", std::to_string(endTime));
+}
+
+long GetHistoricalInstanceReportRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void GetHistoricalInstanceReportRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", std::to_string(startTime));
+}
+
+std::string GetHistoricalInstanceReportRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void GetHistoricalInstanceReportRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

ccc/src/model/GetHistoricalInstanceReportResult.cc

@@ -0,0 +1,244 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ccc/model/GetHistoricalInstanceReportResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+GetHistoricalInstanceReportResult::GetHistoricalInstanceReportResult() :
+	ServiceResult()
+{}
+
+GetHistoricalInstanceReportResult::GetHistoricalInstanceReportResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetHistoricalInstanceReportResult::~GetHistoricalInstanceReportResult()
+{}
+
+void GetHistoricalInstanceReportResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto inboundNode = dataNode["Inbound"];
+	if(!inboundNode["AbandonRate"].isNull())
+		data_.inbound.abandonRate = std::stof(inboundNode["AbandonRate"].asString());
+	if(!inboundNode["AverageAbandonTime"].isNull())
+		data_.inbound.averageAbandonTime = std::stof(inboundNode["AverageAbandonTime"].asString());
+	if(!inboundNode["AverageAbandonedInIVRTime"].isNull())
+		data_.inbound.averageAbandonedInIVRTime = std::stof(inboundNode["AverageAbandonedInIVRTime"].asString());
+	if(!inboundNode["AverageAbandonedInQueueTime"].isNull())
+		data_.inbound.averageAbandonedInQueueTime = std::stof(inboundNode["AverageAbandonedInQueueTime"].asString());
+	if(!inboundNode["AverageAbandonedInRingTime"].isNull())
+		data_.inbound.averageAbandonedInRingTime = std::stof(inboundNode["AverageAbandonedInRingTime"].asString());
+	if(!inboundNode["AverageHoldTime"].isNull())
+		data_.inbound.averageHoldTime = std::stof(inboundNode["AverageHoldTime"].asString());
+	if(!inboundNode["AverageRingTime"].isNull())
+		data_.inbound.averageRingTime = std::stof(inboundNode["AverageRingTime"].asString());
+	if(!inboundNode["AverageTalkTime"].isNull())
+		data_.inbound.averageTalkTime = std::stof(inboundNode["AverageTalkTime"].asString());
+	if(!inboundNode["AverageWaitTime"].isNull())
+		data_.inbound.averageWaitTime = std::stof(inboundNode["AverageWaitTime"].asString());
+	if(!inboundNode["AverageWorkTime"].isNull())
+		data_.inbound.averageWorkTime = std::stof(inboundNode["AverageWorkTime"].asString());
+	if(!inboundNode["CallsAbandoned"].isNull())
+		data_.inbound.callsAbandoned = std::stol(inboundNode["CallsAbandoned"].asString());
+	if(!inboundNode["CallsAbandonedInIVR"].isNull())
+		data_.inbound.callsAbandonedInIVR = std::stol(inboundNode["CallsAbandonedInIVR"].asString());
+	if(!inboundNode["CallsAbandonedInQueue"].isNull())
+		data_.inbound.callsAbandonedInQueue = std::stol(inboundNode["CallsAbandonedInQueue"].asString());
+	if(!inboundNode["CallsAbandonedInRinging"].isNull())
+		data_.inbound.callsAbandonedInRinging = std::stol(inboundNode["CallsAbandonedInRinging"].asString());
+	if(!inboundNode["CallsConsulted"].isNull())
+		data_.inbound.callsConsulted = std::stol(inboundNode["CallsConsulted"].asString());
+	if(!inboundNode["CallsHandled"].isNull())
+		data_.inbound.callsHandled = std::stol(inboundNode["CallsHandled"].asString());
+	if(!inboundNode["CallsHold"].isNull())
+		data_.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
+	if(!inboundNode["CallsOffered"].isNull())
+		data_.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
+	if(!inboundNode["CallsQueued"].isNull())
+		data_.inbound.callsQueued = std::stol(inboundNode["CallsQueued"].asString());
+	if(!inboundNode["CallsRinged"].isNull())
+		data_.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
+	if(!inboundNode["CallsTransferred"].isNull())
+		data_.inbound.callsTransferred = std::stol(inboundNode["CallsTransferred"].asString());
+	if(!inboundNode["HandleRate"].isNull())
+		data_.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
+	if(!inboundNode["MaxAbandonTime"].isNull())
+		data_.inbound.maxAbandonTime = std::stol(inboundNode["MaxAbandonTime"].asString());
+	if(!inboundNode["MaxAbandonedInIVRTime"].isNull())
+		data_.inbound.maxAbandonedInIVRTime = std::stol(inboundNode["MaxAbandonedInIVRTime"].asString());
+	if(!inboundNode["MaxAbandonedInQueueTime"].isNull())
+		data_.inbound.maxAbandonedInQueueTime = std::stol(inboundNode["MaxAbandonedInQueueTime"].asString());
+	if(!inboundNode["MaxAbandonedInRingTime"].isNull())
+		data_.inbound.maxAbandonedInRingTime = std::stol(inboundNode["MaxAbandonedInRingTime"].asString());
+	if(!inboundNode["MaxHoldTime"].isNull())
+		data_.inbound.maxHoldTime = std::stol(inboundNode["MaxHoldTime"].asString());
+	if(!inboundNode["MaxRingTime"].isNull())
+		data_.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
+	if(!inboundNode["MaxTalkTime"].isNull())
+		data_.inbound.maxTalkTime = std::stol(inboundNode["MaxTalkTime"].asString());
+	if(!inboundNode["MaxWaitTime"].isNull())
+		data_.inbound.maxWaitTime = std::stol(inboundNode["MaxWaitTime"].asString());
+	if(!inboundNode["MaxWorkTime"].isNull())
+		data_.inbound.maxWorkTime = std::stol(inboundNode["MaxWorkTime"].asString());
+	if(!inboundNode["SatisfactionIndex"].isNull())
+		data_.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
+	if(!inboundNode["SatisfactionSurveysOffered"].isNull())
+		data_.inbound.satisfactionSurveysOffered = std::stol(inboundNode["SatisfactionSurveysOffered"].asString());
+	if(!inboundNode["SatisfactionSurveysResponded"].isNull())
+		data_.inbound.satisfactionSurveysResponded = std::stol(inboundNode["SatisfactionSurveysResponded"].asString());
+	if(!inboundNode["ServiceLevel20"].isNull())
+		data_.inbound.serviceLevel20 = std::stof(inboundNode["ServiceLevel20"].asString());
+	if(!inboundNode["TotalAbandonTime"].isNull())
+		data_.inbound.totalAbandonTime = std::stol(inboundNode["TotalAbandonTime"].asString());
+	if(!inboundNode["TotalAbandonedInIVRTime"].isNull())
+		data_.inbound.totalAbandonedInIVRTime = std::stol(inboundNode["TotalAbandonedInIVRTime"].asString());
+	if(!inboundNode["TotalAbandonedInQueueTime"].isNull())
+		data_.inbound.totalAbandonedInQueueTime = std::stol(inboundNode["TotalAbandonedInQueueTime"].asString());
+	if(!inboundNode["TotalAbandonedInRingTime"].isNull())
+		data_.inbound.totalAbandonedInRingTime = std::stol(inboundNode["TotalAbandonedInRingTime"].asString());
+	if(!inboundNode["TotalHoldTime"].isNull())
+		data_.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
+	if(!inboundNode["TotalRingTime"].isNull())
+		data_.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
+	if(!inboundNode["TotalTalkTime"].isNull())
+		data_.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
+	if(!inboundNode["TotalWaitTime"].isNull())
+		data_.inbound.totalWaitTime = std::stol(inboundNode["TotalWaitTime"].asString());
+	if(!inboundNode["TotalWorkTime"].isNull())
+		data_.inbound.totalWorkTime = std::stol(inboundNode["TotalWorkTime"].asString());
+	auto outboundNode = dataNode["Outbound"];
+	if(!outboundNode["AnswerRate"].isNull())
+		data_.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
+	if(!outboundNode["AverageDialingTime"].isNull())
+		data_.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
+	if(!outboundNode["AverageHoldTime"].isNull())
+		data_.outbound.averageHoldTime = std::stof(outboundNode["AverageHoldTime"].asString());
+	if(!outboundNode["AverageTalkTime"].isNull())
+		data_.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
+	if(!outboundNode["AverageWorkTime"].isNull())
+		data_.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
+	if(!outboundNode["CallsAnswered"].isNull())
+		data_.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
+	if(!outboundNode["CallsDialed"].isNull())
+		data_.outbound.callsDialed = std::stol(outboundNode["CallsDialed"].asString());
+	if(!outboundNode["CallsDialedSuccess"].isNull())
+		data_.outbound.callsDialedSuccess = std::stol(outboundNode["CallsDialedSuccess"].asString());
+	if(!outboundNode["CallsHold"].isNull())
+		data_.outbound.callsHold = std::stoi(outboundNode["CallsHold"].asString());
+	if(!outboundNode["MaxDialingTime"].isNull())
+		data_.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].asString());
+	if(!outboundNode["MaxHoldTime"].isNull())
+		data_.outbound.maxHoldTime = std::stol(outboundNode["MaxHoldTime"].asString());
+	if(!outboundNode["MaxTalkTime"].isNull())
+		data_.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
+	if(!outboundNode["MaxWorkTime"].isNull())
+		data_.outbound.maxWorkTime = std::stol(outboundNode["MaxWorkTime"].asString());
+	if(!outboundNode["SatisfactionIndex"].isNull())
+		data_.outbound.satisfactionIndex = std::stof(outboundNode["SatisfactionIndex"].asString());
+	if(!outboundNode["SatisfactionSurveysOffered"].isNull())
+		data_.outbound.satisfactionSurveysOffered = std::stol(outboundNode["SatisfactionSurveysOffered"].asString());
+	if(!outboundNode["SatisfactionSurveysResponded"].isNull())
+		data_.outbound.satisfactionSurveysResponded = std::stol(outboundNode["SatisfactionSurveysResponded"].asString());
+	if(!outboundNode["TotalDialingTime"].isNull())
+		data_.outbound.totalDialingTime = std::stol(outboundNode["TotalDialingTime"].asString());
+	if(!outboundNode["TotalHoldTime"].isNull())
+		data_.outbound.totalHoldTime = std::stol(outboundNode["TotalHoldTime"].asString());
+	if(!outboundNode["TotalTalkTime"].isNull())
+		data_.outbound.totalTalkTime = std::stol(outboundNode["TotalTalkTime"].asString());
+	if(!outboundNode["TotalWorkTime"].isNull())
+		data_.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+	auto overallNode = dataNode["Overall"];
+	if(!overallNode["AverageBreakTime"].isNull())
+		data_.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
+	if(!overallNode["AverageHoldTime"].isNull())
+		data_.overall.averageHoldTime = std::stof(overallNode["AverageHoldTime"].asString());
+	if(!overallNode["AverageReadyTime"].isNull())
+		data_.overall.averageReadyTime = std::stof(overallNode["AverageReadyTime"].asString());
+	if(!overallNode["AverageTalkTime"].isNull())
+		data_.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
+	if(!overallNode["AverageWorkTime"].isNull())
+		data_.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
+	if(!overallNode["MaxBreakTime"].isNull())
+		data_.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
+	if(!overallNode["MaxHoldTime"].isNull())
+		data_.overall.maxHoldTime = std::stol(overallNode["MaxHoldTime"].asString());
+	if(!overallNode["MaxReadyTime"].isNull())
+		data_.overall.maxReadyTime = std::stol(overallNode["MaxReadyTime"].asString());
+	if(!overallNode["MaxTalkTime"].isNull())
+		data_.overall.maxTalkTime = std::stol(overallNode["MaxTalkTime"].asString());
+	if(!overallNode["MaxWorkTime"].isNull())
+		data_.overall.maxWorkTime = std::stol(overallNode["MaxWorkTime"].asString());
+	if(!overallNode["OccupancyRate"].isNull())
+		data_.overall.occupancyRate = std::stof(overallNode["OccupancyRate"].asString());
+	if(!overallNode["SatisfactionIndex"].isNull())
+		data_.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].asString());
+	if(!overallNode["SatisfactionSurveysOffered"].isNull())
+		data_.overall.satisfactionSurveysOffered = std::stol(overallNode["SatisfactionSurveysOffered"].asString());
+	if(!overallNode["SatisfactionSurveysResponded"].isNull())
+		data_.overall.satisfactionSurveysResponded = std::stol(overallNode["SatisfactionSurveysResponded"].asString());
+	if(!overallNode["TotalBreakTime"].isNull())
+		data_.overall.totalBreakTime = std::stol(overallNode["TotalBreakTime"].asString());
+	if(!overallNode["TotalCalls"].isNull())
+		data_.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString());
+	if(!overallNode["TotalHoldTime"].isNull())
+		data_.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
+	if(!overallNode["TotalLoggedInTime"].isNull())
+		data_.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
+	if(!overallNode["TotalReadyTime"].isNull())
+		data_.overall.totalReadyTime = std::stol(overallNode["TotalReadyTime"].asString());
+	if(!overallNode["TotalTalkTime"].isNull())
+		data_.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
+	if(!overallNode["TotalWorkTime"].isNull())
+		data_.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string GetHistoricalInstanceReportResult::getMessage()const
+{
+	return message_;
+}
+
+int GetHistoricalInstanceReportResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+GetHistoricalInstanceReportResult::Data GetHistoricalInstanceReportResult::getData()const
+{
+	return data_;
+}
+
+std::string GetHistoricalInstanceReportResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/GetInstanceTrendingReportRequest.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/ccc/model/GetInstanceTrendingReportRequest.h>
+
+using AlibabaCloud::CCC::Model::GetInstanceTrendingReportRequest;
+
+GetInstanceTrendingReportRequest::GetInstanceTrendingReportRequest() :
+	RpcServiceRequest("ccc", "2020-07-01", "GetInstanceTrendingReport")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetInstanceTrendingReportRequest::~GetInstanceTrendingReportRequest()
+{}
+
+long GetInstanceTrendingReportRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void GetInstanceTrendingReportRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", std::to_string(endTime));
+}
+
+long GetInstanceTrendingReportRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void GetInstanceTrendingReportRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", std::to_string(startTime));
+}
+
+std::string GetInstanceTrendingReportRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void GetInstanceTrendingReportRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

ccc/src/model/GetInstanceTrendingReportResult.cc

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ccc/model/GetInstanceTrendingReportResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+GetInstanceTrendingReportResult::GetInstanceTrendingReportResult() :
+	ServiceResult()
+{}
+
+GetInstanceTrendingReportResult::GetInstanceTrendingReportResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetInstanceTrendingReportResult::~GetInstanceTrendingReportResult()
+{}
+
+void GetInstanceTrendingReportResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	auto allInboundNode = dataNode["Inbound"]["InboundItem"];
+	for (auto dataNodeInboundInboundItem : allInboundNode)
+	{
+		Data::InboundItem inboundItemObject;
+		if(!dataNodeInboundInboundItem["CallsAbandonedInIVR"].isNull())
+			inboundItemObject.callsAbandonedInIVR = std::stol(dataNodeInboundInboundItem["CallsAbandonedInIVR"].asString());
+		if(!dataNodeInboundInboundItem["CallsAbandonedInQueue"].isNull())
+			inboundItemObject.callsAbandonedInQueue = std::stol(dataNodeInboundInboundItem["CallsAbandonedInQueue"].asString());
+		if(!dataNodeInboundInboundItem["CallsAbandonedInRinging"].isNull())
+			inboundItemObject.callsAbandonedInRinging = std::stol(dataNodeInboundInboundItem["CallsAbandonedInRinging"].asString());
+		if(!dataNodeInboundInboundItem["CallsHandled"].isNull())
+			inboundItemObject.callsHandled = std::stol(dataNodeInboundInboundItem["CallsHandled"].asString());
+		if(!dataNodeInboundInboundItem["CallsQueued"].isNull())
+			inboundItemObject.callsQueued = std::stol(dataNodeInboundInboundItem["CallsQueued"].asString());
+		if(!dataNodeInboundInboundItem["StatsTime"].isNull())
+			inboundItemObject.statsTime = std::stol(dataNodeInboundInboundItem["StatsTime"].asString());
+		if(!dataNodeInboundInboundItem["TotalCalls"].isNull())
+			inboundItemObject.totalCalls = std::stol(dataNodeInboundInboundItem["TotalCalls"].asString());
+		data_.inbound.push_back(inboundItemObject);
+	}
+	auto allOutboundNode = dataNode["Outbound"]["OutboundItem"];
+	for (auto dataNodeOutboundOutboundItem : allOutboundNode)
+	{
+		Data::OutboundItem outboundItemObject;
+		if(!dataNodeOutboundOutboundItem["CallsAnswered"].isNull())
+			outboundItemObject.callsAnswered = std::stol(dataNodeOutboundOutboundItem["CallsAnswered"].asString());
+		if(!dataNodeOutboundOutboundItem["StatsTime"].isNull())
+			outboundItemObject.statsTime = std::stol(dataNodeOutboundOutboundItem["StatsTime"].asString());
+		if(!dataNodeOutboundOutboundItem["TotalCalls"].isNull())
+			outboundItemObject.totalCalls = std::stol(dataNodeOutboundOutboundItem["TotalCalls"].asString());
+		data_.outbound.push_back(outboundItemObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string GetInstanceTrendingReportResult::getMessage()const
+{
+	return message_;
+}
+
+int GetInstanceTrendingReportResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+GetInstanceTrendingReportResult::Data GetInstanceTrendingReportResult::getData()const
+{
+	return data_;
+}
+
+std::string GetInstanceTrendingReportResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/GetRealtimeInstanceStatesRequest.cc

@@ -14,27 +14,27 @@
  * limitations under the License.
  */
 
-#include <alibabacloud/drds/model/GetBatchEvaluateTaskReportRequest.h>
+#include <alibabacloud/ccc/model/GetRealtimeInstanceStatesRequest.h>
 
-using AlibabaCloud::Drds::Model::GetBatchEvaluateTaskReportRequest;
+using AlibabaCloud::CCC::Model::GetRealtimeInstanceStatesRequest;
 
-GetBatchEvaluateTaskReportRequest::GetBatchEvaluateTaskReportRequest() :
-	RpcServiceRequest("drds", "2019-01-23", "GetBatchEvaluateTaskReport")
+GetRealtimeInstanceStatesRequest::GetRealtimeInstanceStatesRequest() :
+	RpcServiceRequest("ccc", "2020-07-01", "GetRealtimeInstanceStates")
 {
 	setMethod(HttpRequest::Method::Post);
 }
 
-GetBatchEvaluateTaskReportRequest::~GetBatchEvaluateTaskReportRequest()
+GetRealtimeInstanceStatesRequest::~GetRealtimeInstanceStatesRequest()
 {}
 
-long GetBatchEvaluateTaskReportRequest::getBatchEvaluateTaskId()const
+std::string GetRealtimeInstanceStatesRequest::getInstanceId()const
 {
-	return batchEvaluateTaskId_;
+	return instanceId_;
 }
 
-void GetBatchEvaluateTaskReportRequest::setBatchEvaluateTaskId(long batchEvaluateTaskId)
+void GetRealtimeInstanceStatesRequest::setInstanceId(const std::string& instanceId)
 {
-	batchEvaluateTaskId_ = batchEvaluateTaskId;
-	setParameter("BatchEvaluateTaskId", std::to_string(batchEvaluateTaskId));
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
 }
 

ccc/src/model/GetRealtimeInstanceStatesResult.cc

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ccc/model/GetRealtimeInstanceStatesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+GetRealtimeInstanceStatesResult::GetRealtimeInstanceStatesResult() :
+	ServiceResult()
+{}
+
+GetRealtimeInstanceStatesResult::GetRealtimeInstanceStatesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetRealtimeInstanceStatesResult::~GetRealtimeInstanceStatesResult()
+{}
+
+void GetRealtimeInstanceStatesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["BreakingAgents"].isNull())
+		data_.breakingAgents = std::stol(dataNode["BreakingAgents"].asString());
+	if(!dataNode["InstanceId"].isNull())
+		data_.instanceId = dataNode["InstanceId"].asString();
+	if(!dataNode["InteractiveCalls"].isNull())
+		data_.interactiveCalls = std::stol(dataNode["InteractiveCalls"].asString());
+	if(!dataNode["LoggedInAgents"].isNull())
+		data_.loggedInAgents = std::stol(dataNode["LoggedInAgents"].asString());
+	if(!dataNode["LongestCall"].isNull())
+		data_.longestCall = std::stol(dataNode["LongestCall"].asString());
+	if(!dataNode["ReadyAgents"].isNull())
+		data_.readyAgents = std::stol(dataNode["ReadyAgents"].asString());
+	if(!dataNode["TalkingAgents"].isNull())
+		data_.talkingAgents = std::stol(dataNode["TalkingAgents"].asString());
+	if(!dataNode["TotalAgents"].isNull())
+		data_.totalAgents = std::stol(dataNode["TotalAgents"].asString());
+	if(!dataNode["WaitingCalls"].isNull())
+		data_.waitingCalls = std::stol(dataNode["WaitingCalls"].asString());
+	if(!dataNode["WorkingAgents"].isNull())
+		data_.workingAgents = std::stol(dataNode["WorkingAgents"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string GetRealtimeInstanceStatesResult::getMessage()const
+{
+	return message_;
+}
+
+int GetRealtimeInstanceStatesResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+GetRealtimeInstanceStatesResult::Data GetRealtimeInstanceStatesResult::getData()const
+{
+	return data_;
+}
+
+std::string GetRealtimeInstanceStatesResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/ListAgentStateLogsRequest.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/ccc/model/ListAgentStateLogsRequest.h>
+
+using AlibabaCloud::CCC::Model::ListAgentStateLogsRequest;
+
+ListAgentStateLogsRequest::ListAgentStateLogsRequest() :
+	RpcServiceRequest("ccc", "2020-07-01", "ListAgentStateLogs")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListAgentStateLogsRequest::~ListAgentStateLogsRequest()
+{}
+
+std::string ListAgentStateLogsRequest::getAgentId()const
+{
+	return agentId_;
+}
+
+void ListAgentStateLogsRequest::setAgentId(const std::string& agentId)
+{
+	agentId_ = agentId;
+	setParameter("AgentId", agentId);
+}
+
+long ListAgentStateLogsRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void ListAgentStateLogsRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", std::to_string(endTime));
+}
+
+long ListAgentStateLogsRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void ListAgentStateLogsRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", std::to_string(startTime));
+}
+
+std::string ListAgentStateLogsRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void ListAgentStateLogsRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+

ccc/src/model/ListAgentStateLogsResult.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ccc/model/ListAgentStateLogsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+ListAgentStateLogsResult::ListAgentStateLogsResult() :
+	ServiceResult()
+{}
+
+ListAgentStateLogsResult::ListAgentStateLogsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListAgentStateLogsResult::~ListAgentStateLogsResult()
+{}
+
+void ListAgentStateLogsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["Duration"].isNull())
+			dataObject.duration = std::stol(valueDataDataItem["Duration"].asString());
+		if(!valueDataDataItem["StartTime"].isNull())
+			dataObject.startTime = std::stol(valueDataDataItem["StartTime"].asString());
+		if(!valueDataDataItem["State"].isNull())
+			dataObject.state = valueDataDataItem["State"].asString();
+		if(!valueDataDataItem["StateCode"].isNull())
+			dataObject.stateCode = valueDataDataItem["StateCode"].asString();
+		data_.push_back(dataObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ListAgentStateLogsResult::getMessage()const
+{
+	return message_;
+}
+
+int ListAgentStateLogsResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::vector<ListAgentStateLogsResult::DataItem> ListAgentStateLogsResult::getData()const
+{
+	return data_;
+}
+
+std::string ListAgentStateLogsResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/ListCallDetailRecordsRequest.cc

@@ -82,6 +82,17 @@ void ListCallDetailRecordsRequest::setCalledNumber(const std::string& calledNumb
 	setParameter("CalledNumber", calledNumber);
 }
 
+std::string ListCallDetailRecordsRequest::getSatisfactionList()const
+{
+	return satisfactionList_;
+}
+
+void ListCallDetailRecordsRequest::setSatisfactionList(const std::string& satisfactionList)
+{
+	satisfactionList_ = satisfactionList;
+	setParameter("SatisfactionList", satisfactionList);
+}
+
 int ListCallDetailRecordsRequest::getPageSize()const
 {
 	return pageSize_;
@@ -104,17 +115,6 @@ void ListCallDetailRecordsRequest::setSortOrder(const std::string& sortOrder)
 	setParameter("SortOrder", sortOrder);
 }
 
-bool ListCallDetailRecordsRequest::getWithRecording()const
-{
-	return withRecording_;
-}
-
-void ListCallDetailRecordsRequest::setWithRecording(bool withRecording)
-{
-	withRecording_ = withRecording;
-	setParameter("WithRecording", withRecording ? "true" : "false");
-}
-
 std::string ListCallDetailRecordsRequest::getAgentId()const
 {
 	return agentId_;
@@ -137,6 +137,17 @@ void ListCallDetailRecordsRequest::setContactType(const std::string& contactType
 	setParameter("ContactType", contactType);
 }
 
+std::string ListCallDetailRecordsRequest::getSatisfactionSurveyChannel()const
+{
+	return satisfactionSurveyChannel_;
+}
+
+void ListCallDetailRecordsRequest::setSatisfactionSurveyChannel(const std::string& satisfactionSurveyChannel)
+{
+	satisfactionSurveyChannel_ = satisfactionSurveyChannel;
+	setParameter("SatisfactionSurveyChannel", satisfactionSurveyChannel);
+}
+
 long ListCallDetailRecordsRequest::getEndTime()const
 {
 	return endTime_;

ccc/src/model/ListCallDetailRecordsResult.cc

@@ -70,6 +70,18 @@ void ListCallDetailRecordsResult::parse(const std::string &payload)
 			callDetailRecordObject.establishedTime = std::stol(dataNodeListCallDetailRecord["EstablishedTime"].asString());
 		if(!dataNodeListCallDetailRecord["InstanceId"].isNull())
 			callDetailRecordObject.instanceId = dataNodeListCallDetailRecord["InstanceId"].asString();
+		if(!dataNodeListCallDetailRecord["RecordingReady"].isNull())
+			callDetailRecordObject.recordingReady = dataNodeListCallDetailRecord["RecordingReady"].asString() == "true";
+		if(!dataNodeListCallDetailRecord["ReleaseInitiator"].isNull())
+			callDetailRecordObject.releaseInitiator = dataNodeListCallDetailRecord["ReleaseInitiator"].asString();
+		if(!dataNodeListCallDetailRecord["ReleaseTime"].isNull())
+			callDetailRecordObject.releaseTime = std::stol(dataNodeListCallDetailRecord["ReleaseTime"].asString());
+		if(!dataNodeListCallDetailRecord["Satisfaction"].isNull())
+			callDetailRecordObject.satisfaction = std::stoi(dataNodeListCallDetailRecord["Satisfaction"].asString());
+		if(!dataNodeListCallDetailRecord["SatisfactionSurveyChannel"].isNull())
+			callDetailRecordObject.satisfactionSurveyChannel = dataNodeListCallDetailRecord["SatisfactionSurveyChannel"].asString();
+		if(!dataNodeListCallDetailRecord["SatisfactionSurveyOffered"].isNull())
+			callDetailRecordObject.satisfactionSurveyOffered = dataNodeListCallDetailRecord["SatisfactionSurveyOffered"].asString() == "true";
 		if(!dataNodeListCallDetailRecord["SkillGroupIds"].isNull())
 			callDetailRecordObject.skillGroupIds = dataNodeListCallDetailRecord["SkillGroupIds"].asString();
 		if(!dataNodeListCallDetailRecord["SkillGroupNames"].isNull())

ccc/src/model/ListHistoricalAgentReportResult.cc

@@ -55,6 +55,8 @@ void ListHistoricalAgentReportResult::parse(const std::string &payload)
 		if(!dataNodeListItems["AgentName"].isNull())
 			itemsObject.agentName = dataNodeListItems["AgentName"].asString();
 		auto inboundNode = value["Inbound"];
+		if(!inboundNode["AverageHoldTime"].isNull())
+			itemsObject.inbound.averageHoldTime = std::stof(inboundNode["AverageHoldTime"].asString());
 		if(!inboundNode["AverageRingTime"].isNull())
 			itemsObject.inbound.averageRingTime = std::stof(inboundNode["AverageRingTime"].asString());
 		if(!inboundNode["AverageTalkTime"].isNull())
@@ -69,10 +71,12 @@ void ListHistoricalAgentReportResult::parse(const std::string &payload)
 			itemsObject.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
 		if(!inboundNode["CallsOffered"].isNull())
 			itemsObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
-		if(!inboundNode["CallsTransfered"].isNull())
-			itemsObject.inbound.callsTransfered = std::stol(inboundNode["CallsTransfered"].asString());
+		if(!inboundNode["CallsTransferred"].isNull())
+			itemsObject.inbound.callsTransferred = std::stol(inboundNode["CallsTransferred"].asString());
 		if(!inboundNode["HandleRate"].isNull())
 			itemsObject.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
+		if(!inboundNode["MaxHoldTime"].isNull())
+			itemsObject.inbound.maxHoldTime = std::stol(inboundNode["MaxHoldTime"].asString());
 		if(!inboundNode["MaxRingTime"].isNull())
 			itemsObject.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
 		if(!inboundNode["MaxTalkTime"].isNull())
@@ -85,8 +89,6 @@ void ListHistoricalAgentReportResult::parse(const std::string &payload)
 			itemsObject.inbound.satisfactionSurveysOffered = std::stol(inboundNode["SatisfactionSurveysOffered"].asString());
 		if(!inboundNode["SatisfactionSurveysResponded"].isNull())
 			itemsObject.inbound.satisfactionSurveysResponded = std::stol(inboundNode["SatisfactionSurveysResponded"].asString());
-		if(!inboundNode["ServiceLevel20"].isNull())
-			itemsObject.inbound.serviceLevel20 = std::stof(inboundNode["ServiceLevel20"].asString());
 		if(!inboundNode["TotalHoldTime"].isNull())
 			itemsObject.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
 		if(!inboundNode["TotalRingTime"].isNull())
@@ -100,6 +102,8 @@ void ListHistoricalAgentReportResult::parse(const std::string &payload)
 			itemsObject.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
 		if(!outboundNode["AverageDialingTime"].isNull())
 			itemsObject.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
+		if(!outboundNode["AverageHoldTime"].isNull())
+			itemsObject.outbound.averageHoldTime = std::stof(outboundNode["AverageHoldTime"].asString());
 		if(!outboundNode["AverageTalkTime"].isNull())
 			itemsObject.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
 		if(!outboundNode["AverageWorkTime"].isNull())
@@ -108,8 +112,14 @@ void ListHistoricalAgentReportResult::parse(const std::string &payload)
 			itemsObject.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
 		if(!outboundNode["CallsDialed"].isNull())
 			itemsObject.outbound.callsDialed = std::stol(outboundNode["CallsDialed"].asString());
+		if(!outboundNode["CallsDialedSuccess"].isNull())
+			itemsObject.outbound.callsDialedSuccess = std::stol(outboundNode["CallsDialedSuccess"].asString());
+		if(!outboundNode["CallsHold"].isNull())
+			itemsObject.outbound.callsHold = std::stol(outboundNode["CallsHold"].asString());
 		if(!outboundNode["MaxDialingTime"].isNull())
 			itemsObject.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].asString());
+		if(!outboundNode["MaxHoldTime"].isNull())
+			itemsObject.outbound.maxHoldTime = std::stol(outboundNode["MaxHoldTime"].asString());
 		if(!outboundNode["MaxTalkTime"].isNull())
 			itemsObject.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
 		if(!outboundNode["MaxWorkTime"].isNull())

ccc/src/model/ListHistoricalSkillGroupReportRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/ccc/model/ListHistoricalSkillGroupReportRequest.h>
+
+using AlibabaCloud::CCC::Model::ListHistoricalSkillGroupReportRequest;
+
+ListHistoricalSkillGroupReportRequest::ListHistoricalSkillGroupReportRequest() :
+	RpcServiceRequest("ccc", "2020-07-01", "ListHistoricalSkillGroupReport")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListHistoricalSkillGroupReportRequest::~ListHistoricalSkillGroupReportRequest()
+{}
+
+long ListHistoricalSkillGroupReportRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void ListHistoricalSkillGroupReportRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", std::to_string(endTime));
+}
+
+long ListHistoricalSkillGroupReportRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void ListHistoricalSkillGroupReportRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", std::to_string(startTime));
+}
+
+int ListHistoricalSkillGroupReportRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListHistoricalSkillGroupReportRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string ListHistoricalSkillGroupReportRequest::getSkillGroupIdList()const
+{
+	return skillGroupIdList_;
+}
+
+void ListHistoricalSkillGroupReportRequest::setSkillGroupIdList(const std::string& skillGroupIdList)
+{
+	skillGroupIdList_ = skillGroupIdList;
+	setBodyParameter("SkillGroupIdList", skillGroupIdList);
+}
+
+std::string ListHistoricalSkillGroupReportRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void ListHistoricalSkillGroupReportRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+int ListHistoricalSkillGroupReportRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListHistoricalSkillGroupReportRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

ccc/src/model/ListHistoricalSkillGroupReportResult.cc

@@ -0,0 +1,236 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ccc/model/ListHistoricalSkillGroupReportResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+ListHistoricalSkillGroupReportResult::ListHistoricalSkillGroupReportResult() :
+	ServiceResult()
+{}
+
+ListHistoricalSkillGroupReportResult::ListHistoricalSkillGroupReportResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListHistoricalSkillGroupReportResult::~ListHistoricalSkillGroupReportResult()
+{}
+
+void ListHistoricalSkillGroupReportResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["PageNumber"].isNull())
+		data_.pageNumber = std::stoi(dataNode["PageNumber"].asString());
+	if(!dataNode["PageSize"].isNull())
+		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	if(!dataNode["TotalCount"].isNull())
+		data_.totalCount = std::stoi(dataNode["TotalCount"].asString());
+	auto allListNode = dataNode["List"]["Items"];
+	for (auto dataNodeListItems : allListNode)
+	{
+		Data::Items itemsObject;
+		if(!dataNodeListItems["SkillGroupId"].isNull())
+			itemsObject.skillGroupId = dataNodeListItems["SkillGroupId"].asString();
+		if(!dataNodeListItems["SkillGroupName"].isNull())
+			itemsObject.skillGroupName = dataNodeListItems["SkillGroupName"].asString();
+		auto inboundNode = value["Inbound"];
+		if(!inboundNode["AbandonRate"].isNull())
+			itemsObject.inbound.abandonRate = std::stof(inboundNode["AbandonRate"].asString());
+		if(!inboundNode["AverageAbandonTime"].isNull())
+			itemsObject.inbound.averageAbandonTime = std::stof(inboundNode["AverageAbandonTime"].asString());
+		if(!inboundNode["AverageAbandonedInQueueTime"].isNull())
+			itemsObject.inbound.averageAbandonedInQueueTime = std::stof(inboundNode["AverageAbandonedInQueueTime"].asString());
+		if(!inboundNode["AverageAbandonedInRingTime"].isNull())
+			itemsObject.inbound.averageAbandonedInRingTime = std::stof(inboundNode["AverageAbandonedInRingTime"].asString());
+		if(!inboundNode["AverageRingTime"].isNull())
+			itemsObject.inbound.averageRingTime = std::stof(inboundNode["AverageRingTime"].asString());
+		if(!inboundNode["AverageTalkTime"].isNull())
+			itemsObject.inbound.averageTalkTime = std::stof(inboundNode["AverageTalkTime"].asString());
+		if(!inboundNode["AverageWaitTime"].isNull())
+			itemsObject.inbound.averageWaitTime = std::stof(inboundNode["AverageWaitTime"].asString());
+		if(!inboundNode["AverageWorkTime"].isNull())
+			itemsObject.inbound.averageWorkTime = std::stof(inboundNode["AverageWorkTime"].asString());
+		if(!inboundNode["CallsAbandoned"].isNull())
+			itemsObject.inbound.callsAbandoned = std::stol(inboundNode["CallsAbandoned"].asString());
+		if(!inboundNode["CallsAbandonedInQueue"].isNull())
+			itemsObject.inbound.callsAbandonedInQueue = std::stol(inboundNode["CallsAbandonedInQueue"].asString());
+		if(!inboundNode["CallsAbandonedInRinging"].isNull())
+			itemsObject.inbound.callsAbandonedInRinging = std::stol(inboundNode["CallsAbandonedInRinging"].asString());
+		if(!inboundNode["CallsConsulted"].isNull())
+			itemsObject.inbound.callsConsulted = std::stol(inboundNode["CallsConsulted"].asString());
+		if(!inboundNode["CallsHandled"].isNull())
+			itemsObject.inbound.callsHandled = std::stol(inboundNode["CallsHandled"].asString());
+		if(!inboundNode["CallsHold"].isNull())
+			itemsObject.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
+		if(!inboundNode["CallsOffered"].isNull())
+			itemsObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
+		if(!inboundNode["CallsQueued"].isNull())
+			itemsObject.inbound.callsQueued = std::stol(inboundNode["CallsQueued"].asString());
+		if(!inboundNode["CallsRinged"].isNull())
+			itemsObject.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
+		if(!inboundNode["CallsTransferred"].isNull())
+			itemsObject.inbound.callsTransferred = std::stol(inboundNode["CallsTransferred"].asString());
+		if(!inboundNode["HandleRate"].isNull())
+			itemsObject.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
+		if(!inboundNode["MaxAbandonTime"].isNull())
+			itemsObject.inbound.maxAbandonTime = std::stol(inboundNode["MaxAbandonTime"].asString());
+		if(!inboundNode["MaxAbandonedInQueueTime"].isNull())
+			itemsObject.inbound.maxAbandonedInQueueTime = std::stol(inboundNode["MaxAbandonedInQueueTime"].asString());
+		if(!inboundNode["MaxAbandonedInRingTime"].isNull())
+			itemsObject.inbound.maxAbandonedInRingTime = std::stol(inboundNode["MaxAbandonedInRingTime"].asString());
+		if(!inboundNode["MaxRingTime"].isNull())
+			itemsObject.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
+		if(!inboundNode["MaxTalkTime"].isNull())
+			itemsObject.inbound.maxTalkTime = std::stol(inboundNode["MaxTalkTime"].asString());
+		if(!inboundNode["MaxWaitTime"].isNull())
+			itemsObject.inbound.maxWaitTime = std::stol(inboundNode["MaxWaitTime"].asString());
+		if(!inboundNode["MaxWorkTime"].isNull())
+			itemsObject.inbound.maxWorkTime = std::stol(inboundNode["MaxWorkTime"].asString());
+		if(!inboundNode["SatisfactionIndex"].isNull())
+			itemsObject.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
+		if(!inboundNode["SatisfactionSurveysOffered"].isNull())
+			itemsObject.inbound.satisfactionSurveysOffered = std::stol(inboundNode["SatisfactionSurveysOffered"].asString());
+		if(!inboundNode["SatisfactionSurveysResponded"].isNull())
+			itemsObject.inbound.satisfactionSurveysResponded = std::stol(inboundNode["SatisfactionSurveysResponded"].asString());
+		if(!inboundNode["ServiceLevel20"].isNull())
+			itemsObject.inbound.serviceLevel20 = std::stof(inboundNode["ServiceLevel20"].asString());
+		if(!inboundNode["TotalAbandonTime"].isNull())
+			itemsObject.inbound.totalAbandonTime = std::stol(inboundNode["TotalAbandonTime"].asString());
+		if(!inboundNode["TotalAbandonedInQueueTime"].isNull())
+			itemsObject.inbound.totalAbandonedInQueueTime = std::stol(inboundNode["TotalAbandonedInQueueTime"].asString());
+		if(!inboundNode["TotalAbandonedInRingTime"].isNull())
+			itemsObject.inbound.totalAbandonedInRingTime = std::stol(inboundNode["TotalAbandonedInRingTime"].asString());
+		if(!inboundNode["TotalHoldTime"].isNull())
+			itemsObject.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
+		if(!inboundNode["TotalRingTime"].isNull())
+			itemsObject.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
+		if(!inboundNode["TotalTalkTime"].isNull())
+			itemsObject.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
+		if(!inboundNode["TotalWaitTime"].isNull())
+			itemsObject.inbound.totalWaitTime = std::stol(inboundNode["TotalWaitTime"].asString());
+		if(!inboundNode["TotalWorkTime"].isNull())
+			itemsObject.inbound.totalWorkTime = std::stol(inboundNode["TotalWorkTime"].asString());
+		auto outboundNode = value["Outbound"];
+		if(!outboundNode["AnswerRate"].isNull())
+			itemsObject.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
+		if(!outboundNode["AverageDialingTime"].isNull())
+			itemsObject.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
+		if(!outboundNode["AverageTalkTime"].isNull())
+			itemsObject.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
+		if(!outboundNode["AverageWorkTime"].isNull())
+			itemsObject.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
+		if(!outboundNode["CallsAnswered"].isNull())
+			itemsObject.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
+		if(!outboundNode["CallsDialed"].isNull())
+			itemsObject.outbound.callsDialed = std::stol(outboundNode["CallsDialed"].asString());
+		if(!outboundNode["MaxDialingTime"].isNull())
+			itemsObject.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].asString());
+		if(!outboundNode["MaxTalkTime"].isNull())
+			itemsObject.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
+		if(!outboundNode["MaxWorkTime"].isNull())
+			itemsObject.outbound.maxWorkTime = std::stol(outboundNode["MaxWorkTime"].asString());
+		if(!outboundNode["SatisfactionIndex"].isNull())
+			itemsObject.outbound.satisfactionIndex = std::stof(outboundNode["SatisfactionIndex"].asString());
+		if(!outboundNode["SatisfactionSurveysOffered"].isNull())
+			itemsObject.outbound.satisfactionSurveysOffered = std::stol(outboundNode["SatisfactionSurveysOffered"].asString());
+		if(!outboundNode["SatisfactionSurveysResponded"].isNull())
+			itemsObject.outbound.satisfactionSurveysResponded = std::stol(outboundNode["SatisfactionSurveysResponded"].asString());
+		if(!outboundNode["TotalDialingTime"].isNull())
+			itemsObject.outbound.totalDialingTime = std::stol(outboundNode["TotalDialingTime"].asString());
+		if(!outboundNode["TotalHoldTime"].isNull())
+			itemsObject.outbound.totalHoldTime = std::stol(outboundNode["TotalHoldTime"].asString());
+		if(!outboundNode["TotalTalkTime"].isNull())
+			itemsObject.outbound.totalTalkTime = std::stol(outboundNode["TotalTalkTime"].asString());
+		if(!outboundNode["TotalWorkTime"].isNull())
+			itemsObject.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+		auto overallNode = value["Overall"];
+		if(!overallNode["AverageBreakTime"].isNull())
+			itemsObject.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
+		if(!overallNode["AverageReadyTime"].isNull())
+			itemsObject.overall.averageReadyTime = std::stof(overallNode["AverageReadyTime"].asString());
+		if(!overallNode["AverageTalkTime"].isNull())
+			itemsObject.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
+		if(!overallNode["AverageWorkTime"].isNull())
+			itemsObject.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
+		if(!overallNode["MaxBreakTime"].isNull())
+			itemsObject.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
+		if(!overallNode["MaxReadyTime"].isNull())
+			itemsObject.overall.maxReadyTime = std::stol(overallNode["MaxReadyTime"].asString());
+		if(!overallNode["MaxTalkTime"].isNull())
+			itemsObject.overall.maxTalkTime = std::stol(overallNode["MaxTalkTime"].asString());
+		if(!overallNode["MaxWorkTime"].isNull())
+			itemsObject.overall.maxWorkTime = std::stol(overallNode["MaxWorkTime"].asString());
+		if(!overallNode["OccupancyRate"].isNull())
+			itemsObject.overall.occupancyRate = std::stof(overallNode["OccupancyRate"].asString());
+		if(!overallNode["SatisfactionIndex"].isNull())
+			itemsObject.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].asString());
+		if(!overallNode["SatisfactionSurveysOffered"].isNull())
+			itemsObject.overall.satisfactionSurveysOffered = std::stol(overallNode["SatisfactionSurveysOffered"].asString());
+		if(!overallNode["SatisfactionSurveysResponded"].isNull())
+			itemsObject.overall.satisfactionSurveysResponded = std::stol(overallNode["SatisfactionSurveysResponded"].asString());
+		if(!overallNode["TotalBreakTime"].isNull())
+			itemsObject.overall.totalBreakTime = std::stol(overallNode["TotalBreakTime"].asString());
+		if(!overallNode["TotalCalls"].isNull())
+			itemsObject.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString());
+		if(!overallNode["TotalHoldTime"].isNull())
+			itemsObject.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
+		if(!overallNode["TotalLoggedInTime"].isNull())
+			itemsObject.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
+		if(!overallNode["TotalReadyTime"].isNull())
+			itemsObject.overall.totalReadyTime = std::stol(overallNode["TotalReadyTime"].asString());
+		if(!overallNode["TotalTalkTime"].isNull())
+			itemsObject.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
+		if(!overallNode["TotalWorkTime"].isNull())
+			itemsObject.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
+		data_.list.push_back(itemsObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ListHistoricalSkillGroupReportResult::getMessage()const
+{
+	return message_;
+}
+
+int ListHistoricalSkillGroupReportResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+ListHistoricalSkillGroupReportResult::Data ListHistoricalSkillGroupReportResult::getData()const
+{
+	return data_;
+}
+
+std::string ListHistoricalSkillGroupReportResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/ListIntervalAgentReportRequest.cc

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

ccc/src/model/ListIntervalAgentReportResult.cc

@@ -0,0 +1,193 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ccc/model/ListIntervalAgentReportResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+ListIntervalAgentReportResult::ListIntervalAgentReportResult() :
+	ServiceResult()
+{}
+
+ListIntervalAgentReportResult::ListIntervalAgentReportResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListIntervalAgentReportResult::~ListIntervalAgentReportResult()
+{}
+
+void ListIntervalAgentReportResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["StatsTime"].isNull())
+			dataObject.statsTime = std::stol(valueDataDataItem["StatsTime"].asString());
+		auto inboundNode = value["Inbound"];
+		if(!inboundNode["AverageRingTime"].isNull())
+			dataObject.inbound.averageRingTime = std::stof(inboundNode["AverageRingTime"].asString());
+		if(!inboundNode["AverageTalkTime"].isNull())
+			dataObject.inbound.averageTalkTime = std::stof(inboundNode["AverageTalkTime"].asString());
+		if(!inboundNode["AverageWorkTime"].isNull())
+			dataObject.inbound.averageWorkTime = std::stof(inboundNode["AverageWorkTime"].asString());
+		if(!inboundNode["CallsConsulted"].isNull())
+			dataObject.inbound.callsConsulted = std::stol(inboundNode["CallsConsulted"].asString());
+		if(!inboundNode["CallsHandled"].isNull())
+			dataObject.inbound.callsHandled = std::stol(inboundNode["CallsHandled"].asString());
+		if(!inboundNode["CallsHold"].isNull())
+			dataObject.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
+		if(!inboundNode["CallsOffered"].isNull())
+			dataObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
+		if(!inboundNode["CallsTransferred"].isNull())
+			dataObject.inbound.callsTransferred = std::stol(inboundNode["CallsTransferred"].asString());
+		if(!inboundNode["HandleRate"].isNull())
+			dataObject.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
+		if(!inboundNode["MaxRingTime"].isNull())
+			dataObject.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
+		if(!inboundNode["MaxTalkTime"].isNull())
+			dataObject.inbound.maxTalkTime = std::stol(inboundNode["MaxTalkTime"].asString());
+		if(!inboundNode["MaxWorkTime"].isNull())
+			dataObject.inbound.maxWorkTime = std::stol(inboundNode["MaxWorkTime"].asString());
+		if(!inboundNode["SatisfactionIndex"].isNull())
+			dataObject.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
+		if(!inboundNode["SatisfactionSurveysOffered"].isNull())
+			dataObject.inbound.satisfactionSurveysOffered = std::stol(inboundNode["SatisfactionSurveysOffered"].asString());
+		if(!inboundNode["SatisfactionSurveysResponded"].isNull())
+			dataObject.inbound.satisfactionSurveysResponded = std::stol(inboundNode["SatisfactionSurveysResponded"].asString());
+		if(!inboundNode["TotalHoldTime"].isNull())
+			dataObject.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
+		if(!inboundNode["TotalRingTime"].isNull())
+			dataObject.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
+		if(!inboundNode["TotalTalkTime"].isNull())
+			dataObject.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
+		if(!inboundNode["TotalWorkTime"].isNull())
+			dataObject.inbound.totalWorkTime = std::stol(inboundNode["TotalWorkTime"].asString());
+		auto outboundNode = value["Outbound"];
+		if(!outboundNode["AnswerRate"].isNull())
+			dataObject.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
+		if(!outboundNode["AverageDialingTime"].isNull())
+			dataObject.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
+		if(!outboundNode["AverageTalkTime"].isNull())
+			dataObject.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
+		if(!outboundNode["AverageWorkTime"].isNull())
+			dataObject.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
+		if(!outboundNode["CallsAnswered"].isNull())
+			dataObject.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
+		if(!outboundNode["CallsDialed"].isNull())
+			dataObject.outbound.callsDialed = std::stol(outboundNode["CallsDialed"].asString());
+		if(!outboundNode["MaxDialingTime"].isNull())
+			dataObject.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].asString());
+		if(!outboundNode["MaxTalkTime"].isNull())
+			dataObject.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
+		if(!outboundNode["MaxWorkTime"].isNull())
+			dataObject.outbound.maxWorkTime = std::stol(outboundNode["MaxWorkTime"].asString());
+		if(!outboundNode["SatisfactionIndex"].isNull())
+			dataObject.outbound.satisfactionIndex = std::stof(outboundNode["SatisfactionIndex"].asString());
+		if(!outboundNode["SatisfactionSurveysOffered"].isNull())
+			dataObject.outbound.satisfactionSurveysOffered = std::stol(outboundNode["SatisfactionSurveysOffered"].asString());
+		if(!outboundNode["SatisfactionSurveysResponded"].isNull())
+			dataObject.outbound.satisfactionSurveysResponded = std::stol(outboundNode["SatisfactionSurveysResponded"].asString());
+		if(!outboundNode["TotalDialingTime"].isNull())
+			dataObject.outbound.totalDialingTime = std::stol(outboundNode["TotalDialingTime"].asString());
+		if(!outboundNode["TotalHoldTime"].isNull())
+			dataObject.outbound.totalHoldTime = std::stol(outboundNode["TotalHoldTime"].asString());
+		if(!outboundNode["TotalTalkTime"].isNull())
+			dataObject.outbound.totalTalkTime = std::stol(outboundNode["TotalTalkTime"].asString());
+		if(!outboundNode["TotalWorkTime"].isNull())
+			dataObject.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+		auto overallNode = value["Overall"];
+		if(!overallNode["AverageBreakTime"].isNull())
+			dataObject.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
+		if(!overallNode["AverageReadyTime"].isNull())
+			dataObject.overall.averageReadyTime = std::stof(overallNode["AverageReadyTime"].asString());
+		if(!overallNode["AverageTalkTime"].isNull())
+			dataObject.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
+		if(!overallNode["AverageWorkTime"].isNull())
+			dataObject.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
+		if(!overallNode["FirstCheckInTime"].isNull())
+			dataObject.overall.firstCheckInTime = std::stol(overallNode["FirstCheckInTime"].asString());
+		if(!overallNode["LastCheckoutTime"].isNull())
+			dataObject.overall.lastCheckoutTime = std::stol(overallNode["LastCheckoutTime"].asString());
+		if(!overallNode["MaxBreakTime"].isNull())
+			dataObject.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
+		if(!overallNode["MaxReadyTime"].isNull())
+			dataObject.overall.maxReadyTime = std::stol(overallNode["MaxReadyTime"].asString());
+		if(!overallNode["MaxTalkTime"].isNull())
+			dataObject.overall.maxTalkTime = std::stol(overallNode["MaxTalkTime"].asString());
+		if(!overallNode["MaxWorkTime"].isNull())
+			dataObject.overall.maxWorkTime = std::stol(overallNode["MaxWorkTime"].asString());
+		if(!overallNode["OccupancyRate"].isNull())
+			dataObject.overall.occupancyRate = std::stof(overallNode["OccupancyRate"].asString());
+		if(!overallNode["SatisfactionIndex"].isNull())
+			dataObject.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].asString());
+		if(!overallNode["SatisfactionSurveysOffered"].isNull())
+			dataObject.overall.satisfactionSurveysOffered = std::stol(overallNode["SatisfactionSurveysOffered"].asString());
+		if(!overallNode["SatisfactionSurveysResponded"].isNull())
+			dataObject.overall.satisfactionSurveysResponded = std::stol(overallNode["SatisfactionSurveysResponded"].asString());
+		if(!overallNode["TotalBreakTime"].isNull())
+			dataObject.overall.totalBreakTime = std::stol(overallNode["TotalBreakTime"].asString());
+		if(!overallNode["TotalCalls"].isNull())
+			dataObject.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString());
+		if(!overallNode["TotalHoldTime"].isNull())
+			dataObject.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
+		if(!overallNode["TotalLoggedInTime"].isNull())
+			dataObject.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
+		if(!overallNode["TotalReadyTime"].isNull())
+			dataObject.overall.totalReadyTime = std::stol(overallNode["TotalReadyTime"].asString());
+		if(!overallNode["TotalTalkTime"].isNull())
+			dataObject.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
+		if(!overallNode["TotalWorkTime"].isNull())
+			dataObject.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
+		data_.push_back(dataObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ListIntervalAgentReportResult::getMessage()const
+{
+	return message_;
+}
+
+int ListIntervalAgentReportResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::vector<ListIntervalAgentReportResult::DataItem> ListIntervalAgentReportResult::getData()const
+{
+	return data_;
+}
+
+std::string ListIntervalAgentReportResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/ListIntervalInstanceReportRequest.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/ccc/model/ListIntervalInstanceReportRequest.h>
+
+using AlibabaCloud::CCC::Model::ListIntervalInstanceReportRequest;
+
+ListIntervalInstanceReportRequest::ListIntervalInstanceReportRequest() :
+	RpcServiceRequest("ccc", "2020-07-01", "ListIntervalInstanceReport")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListIntervalInstanceReportRequest::~ListIntervalInstanceReportRequest()
+{}
+
+long ListIntervalInstanceReportRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void ListIntervalInstanceReportRequest::setEndTime(long endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", std::to_string(endTime));
+}
+
+long ListIntervalInstanceReportRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void ListIntervalInstanceReportRequest::setStartTime(long startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", std::to_string(startTime));
+}
+
+std::string ListIntervalInstanceReportRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void ListIntervalInstanceReportRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string ListIntervalInstanceReportRequest::getInterval()const
+{
+	return interval_;
+}
+
+void ListIntervalInstanceReportRequest::setInterval(const std::string& interval)
+{
+	interval_ = interval;
+	setParameter("Interval", interval);
+}
+

ccc/src/model/ListIntervalInstanceReportResult.cc

@@ -0,0 +1,245 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ccc/model/ListIntervalInstanceReportResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+ListIntervalInstanceReportResult::ListIntervalInstanceReportResult() :
+	ServiceResult()
+{}
+
+ListIntervalInstanceReportResult::ListIntervalInstanceReportResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListIntervalInstanceReportResult::~ListIntervalInstanceReportResult()
+{}
+
+void ListIntervalInstanceReportResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["StatsTime"].isNull())
+			dataObject.statsTime = std::stol(valueDataDataItem["StatsTime"].asString());
+		auto inboundNode = value["Inbound"];
+		if(!inboundNode["AbandonedRate"].isNull())
+			dataObject.inbound.abandonedRate = std::stof(inboundNode["AbandonedRate"].asString());
+		if(!inboundNode["AverageAbandonTime"].isNull())
+			dataObject.inbound.averageAbandonTime = std::stof(inboundNode["AverageAbandonTime"].asString());
+		if(!inboundNode["AverageAbandonedInIVRTime"].isNull())
+			dataObject.inbound.averageAbandonedInIVRTime = std::stof(inboundNode["AverageAbandonedInIVRTime"].asString());
+		if(!inboundNode["AverageAbandonedInQueueTime"].isNull())
+			dataObject.inbound.averageAbandonedInQueueTime = std::stof(inboundNode["AverageAbandonedInQueueTime"].asString());
+		if(!inboundNode["AverageAbandonedInRingTime"].isNull())
+			dataObject.inbound.averageAbandonedInRingTime = std::stof(inboundNode["AverageAbandonedInRingTime"].asString());
+		if(!inboundNode["AverageHoldTime"].isNull())
+			dataObject.inbound.averageHoldTime = std::stof(inboundNode["AverageHoldTime"].asString());
+		if(!inboundNode["AverageRingTime"].isNull())
+			dataObject.inbound.averageRingTime = std::stof(inboundNode["AverageRingTime"].asString());
+		if(!inboundNode["AverageTalkTime"].isNull())
+			dataObject.inbound.averageTalkTime = std::stof(inboundNode["AverageTalkTime"].asString());
+		if(!inboundNode["AverageWaitTime"].isNull())
+			dataObject.inbound.averageWaitTime = std::stof(inboundNode["AverageWaitTime"].asString());
+		if(!inboundNode["AverageWorkTime"].isNull())
+			dataObject.inbound.averageWorkTime = std::stof(inboundNode["AverageWorkTime"].asString());
+		if(!inboundNode["CallsAbandoned"].isNull())
+			dataObject.inbound.callsAbandoned = std::stol(inboundNode["CallsAbandoned"].asString());
+		if(!inboundNode["CallsAbandonedInIVR"].isNull())
+			dataObject.inbound.callsAbandonedInIVR = std::stol(inboundNode["CallsAbandonedInIVR"].asString());
+		if(!inboundNode["CallsAbandonedInQueue"].isNull())
+			dataObject.inbound.callsAbandonedInQueue = std::stol(inboundNode["CallsAbandonedInQueue"].asString());
+		if(!inboundNode["CallsAbandonedInRinging"].isNull())
+			dataObject.inbound.callsAbandonedInRinging = std::stol(inboundNode["CallsAbandonedInRinging"].asString());
+		if(!inboundNode["CallsConsulted"].isNull())
+			dataObject.inbound.callsConsulted = std::stol(inboundNode["CallsConsulted"].asString());
+		if(!inboundNode["CallsHandled"].isNull())
+			dataObject.inbound.callsHandled = std::stol(inboundNode["CallsHandled"].asString());
+		if(!inboundNode["CallsHold"].isNull())
+			dataObject.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
+		if(!inboundNode["CallsOffered"].isNull())
+			dataObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
+		if(!inboundNode["CallsQueued"].isNull())
+			dataObject.inbound.callsQueued = std::stol(inboundNode["CallsQueued"].asString());
+		if(!inboundNode["CallsRinged"].isNull())
+			dataObject.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
+		if(!inboundNode["CallsTransferred"].isNull())
+			dataObject.inbound.callsTransferred = std::stol(inboundNode["CallsTransferred"].asString());
+		if(!inboundNode["HandleRate"].isNull())
+			dataObject.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
+		if(!inboundNode["MaxAbandonTime"].isNull())
+			dataObject.inbound.maxAbandonTime = std::stol(inboundNode["MaxAbandonTime"].asString());
+		if(!inboundNode["MaxAbandonedInIVRTime"].isNull())
+			dataObject.inbound.maxAbandonedInIVRTime = std::stol(inboundNode["MaxAbandonedInIVRTime"].asString());
+		if(!inboundNode["MaxAbandonedInQueueTime"].isNull())
+			dataObject.inbound.maxAbandonedInQueueTime = std::stol(inboundNode["MaxAbandonedInQueueTime"].asString());
+		if(!inboundNode["MaxAbandonedInRingTime"].isNull())
+			dataObject.inbound.maxAbandonedInRingTime = std::stol(inboundNode["MaxAbandonedInRingTime"].asString());
+		if(!inboundNode["MaxHoldTime"].isNull())
+			dataObject.inbound.maxHoldTime = std::stol(inboundNode["MaxHoldTime"].asString());
+		if(!inboundNode["MaxRingTime"].isNull())
+			dataObject.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
+		if(!inboundNode["MaxTalkTime"].isNull())
+			dataObject.inbound.maxTalkTime = std::stol(inboundNode["MaxTalkTime"].asString());
+		if(!inboundNode["MaxWaitTime"].isNull())
+			dataObject.inbound.maxWaitTime = std::stol(inboundNode["MaxWaitTime"].asString());
+		if(!inboundNode["MaxWorkTime"].isNull())
+			dataObject.inbound.maxWorkTime = std::stol(inboundNode["MaxWorkTime"].asString());
+		if(!inboundNode["SatisfactionIndex"].isNull())
+			dataObject.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
+		if(!inboundNode["SatisfactionSurveysOffered"].isNull())
+			dataObject.inbound.satisfactionSurveysOffered = std::stol(inboundNode["SatisfactionSurveysOffered"].asString());
+		if(!inboundNode["SatisfactionSurveysResponded"].isNull())
+			dataObject.inbound.satisfactionSurveysResponded = std::stol(inboundNode["SatisfactionSurveysResponded"].asString());
+		if(!inboundNode["ServiceLevel20"].isNull())
+			dataObject.inbound.serviceLevel20 = std::stof(inboundNode["ServiceLevel20"].asString());
+		if(!inboundNode["TotalAbandonTime"].isNull())
+			dataObject.inbound.totalAbandonTime = std::stol(inboundNode["TotalAbandonTime"].asString());
+		if(!inboundNode["TotalAbandonedInIVRTime"].isNull())
+			dataObject.inbound.totalAbandonedInIVRTime = std::stol(inboundNode["TotalAbandonedInIVRTime"].asString());
+		if(!inboundNode["TotalAbandonedInQueueTime"].isNull())
+			dataObject.inbound.totalAbandonedInQueueTime = std::stol(inboundNode["TotalAbandonedInQueueTime"].asString());
+		if(!inboundNode["TotalAbandonedInRingTime"].isNull())
+			dataObject.inbound.totalAbandonedInRingTime = std::stol(inboundNode["TotalAbandonedInRingTime"].asString());
+		if(!inboundNode["TotalHoldTime"].isNull())
+			dataObject.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
+		if(!inboundNode["TotalRingTime"].isNull())
+			dataObject.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
+		if(!inboundNode["TotalTalkTime"].isNull())
+			dataObject.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
+		if(!inboundNode["TotalWaitTime"].isNull())
+			dataObject.inbound.totalWaitTime = std::stol(inboundNode["TotalWaitTime"].asString());
+		if(!inboundNode["TotalWorkTime"].isNull())
+			dataObject.inbound.totalWorkTime = std::stol(inboundNode["TotalWorkTime"].asString());
+		auto outboundNode = value["Outbound"];
+		if(!outboundNode["AnswerRate"].isNull())
+			dataObject.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
+		if(!outboundNode["AverageDialingTime"].isNull())
+			dataObject.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
+		if(!outboundNode["AverageTalkTime"].isNull())
+			dataObject.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
+		if(!outboundNode["AverageWorkTime"].isNull())
+			dataObject.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
+		if(!outboundNode["CallsAnswered"].isNull())
+			dataObject.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
+		if(!outboundNode["CallsDialed"].isNull())
+			dataObject.outbound.callsDialed = std::stol(outboundNode["CallsDialed"].asString());
+		if(!outboundNode["CallsDialedSuccess"].isNull())
+			dataObject.outbound.callsDialedSuccess = std::stol(outboundNode["CallsDialedSuccess"].asString());
+		if(!outboundNode["MaxDialingTime"].isNull())
+			dataObject.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].asString());
+		if(!outboundNode["MaxTalkTime"].isNull())
+			dataObject.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
+		if(!outboundNode["MaxWorkTime"].isNull())
+			dataObject.outbound.maxWorkTime = std::stol(outboundNode["MaxWorkTime"].asString());
+		if(!outboundNode["SatisfactionIndex"].isNull())
+			dataObject.outbound.satisfactionIndex = std::stof(outboundNode["SatisfactionIndex"].asString());
+		if(!outboundNode["SatisfactionSurveysOffered"].isNull())
+			dataObject.outbound.satisfactionSurveysOffered = std::stol(outboundNode["SatisfactionSurveysOffered"].asString());
+		if(!outboundNode["SatisfactionSurveysResponded"].isNull())
+			dataObject.outbound.satisfactionSurveysResponded = std::stol(outboundNode["SatisfactionSurveysResponded"].asString());
+		if(!outboundNode["TotalDialingTime"].isNull())
+			dataObject.outbound.totalDialingTime = std::stol(outboundNode["TotalDialingTime"].asString());
+		if(!outboundNode["TotalHoldTime"].isNull())
+			dataObject.outbound.totalHoldTime = std::stol(outboundNode["TotalHoldTime"].asString());
+		if(!outboundNode["TotalTalkTime"].isNull())
+			dataObject.outbound.totalTalkTime = std::stol(outboundNode["TotalTalkTime"].asString());
+		if(!outboundNode["TotalWorkTime"].isNull())
+			dataObject.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+		auto overallNode = value["Overall"];
+		if(!overallNode["AverageBreakTime"].isNull())
+			dataObject.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
+		if(!overallNode["AverageHoldTime"].isNull())
+			dataObject.overall.averageHoldTime = std::stof(overallNode["AverageHoldTime"].asString());
+		if(!overallNode["AverageReadyTime"].isNull())
+			dataObject.overall.averageReadyTime = std::stof(overallNode["AverageReadyTime"].asString());
+		if(!overallNode["AverageTalkTime"].isNull())
+			dataObject.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
+		if(!overallNode["AverageWorkTime"].isNull())
+			dataObject.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
+		if(!overallNode["MaxBreakTime"].isNull())
+			dataObject.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
+		if(!overallNode["MaxHoldTime"].isNull())
+			dataObject.overall.maxHoldTime = std::stol(overallNode["MaxHoldTime"].asString());
+		if(!overallNode["MaxReadyTime"].isNull())
+			dataObject.overall.maxReadyTime = std::stol(overallNode["MaxReadyTime"].asString());
+		if(!overallNode["MaxTalkTime"].isNull())
+			dataObject.overall.maxTalkTime = std::stol(overallNode["MaxTalkTime"].asString());
+		if(!overallNode["MaxWorkTime"].isNull())
+			dataObject.overall.maxWorkTime = std::stol(overallNode["MaxWorkTime"].asString());
+		if(!overallNode["OccupancyRate"].isNull())
+			dataObject.overall.occupancyRate = std::stof(overallNode["OccupancyRate"].asString());
+		if(!overallNode["SatisfactionIndex"].isNull())
+			dataObject.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].asString());
+		if(!overallNode["SatisfactionSurveysOffered"].isNull())
+			dataObject.overall.satisfactionSurveysOffered = std::stol(overallNode["SatisfactionSurveysOffered"].asString());
+		if(!overallNode["SatisfactionSurveysResponded"].isNull())
+			dataObject.overall.satisfactionSurveysResponded = std::stol(overallNode["SatisfactionSurveysResponded"].asString());
+		if(!overallNode["TotalBreakTime"].isNull())
+			dataObject.overall.totalBreakTime = std::stol(overallNode["TotalBreakTime"].asString());
+		if(!overallNode["TotalCalls"].isNull())
+			dataObject.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString());
+		if(!overallNode["TotalHoldTime"].isNull())
+			dataObject.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
+		if(!overallNode["TotalLoggedInTime"].isNull())
+			dataObject.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
+		if(!overallNode["TotalReadyTime"].isNull())
+			dataObject.overall.totalReadyTime = std::stol(overallNode["TotalReadyTime"].asString());
+		if(!overallNode["TotalTalkTime"].isNull())
+			dataObject.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
+		if(!overallNode["TotalWorkTime"].isNull())
+			dataObject.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
+		data_.push_back(dataObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ListIntervalInstanceReportResult::getMessage()const
+{
+	return message_;
+}
+
+int ListIntervalInstanceReportResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::vector<ListIntervalInstanceReportResult::DataItem> ListIntervalInstanceReportResult::getData()const
+{
+	return data_;
+}
+
+std::string ListIntervalInstanceReportResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/ListIntervalSkillGroupReportRequest.cc

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

ccc/src/model/ListIntervalSkillGroupReportResult.cc

@@ -0,0 +1,227 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ccc/model/ListIntervalSkillGroupReportResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+ListIntervalSkillGroupReportResult::ListIntervalSkillGroupReportResult() :
+	ServiceResult()
+{}
+
+ListIntervalSkillGroupReportResult::ListIntervalSkillGroupReportResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListIntervalSkillGroupReportResult::~ListIntervalSkillGroupReportResult()
+{}
+
+void ListIntervalSkillGroupReportResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["StatsTime"].isNull())
+			dataObject.statsTime = std::stol(valueDataDataItem["StatsTime"].asString());
+		auto inboundNode = value["Inbound"];
+		if(!inboundNode["AbandonRate"].isNull())
+			dataObject.inbound.abandonRate = std::stof(inboundNode["AbandonRate"].asString());
+		if(!inboundNode["AverageAbandonTime"].isNull())
+			dataObject.inbound.averageAbandonTime = std::stof(inboundNode["AverageAbandonTime"].asString());
+		if(!inboundNode["AverageAbandonedInQueueTime"].isNull())
+			dataObject.inbound.averageAbandonedInQueueTime = std::stof(inboundNode["AverageAbandonedInQueueTime"].asString());
+		if(!inboundNode["AverageAbandonedInRingTime"].isNull())
+			dataObject.inbound.averageAbandonedInRingTime = std::stof(inboundNode["AverageAbandonedInRingTime"].asString());
+		if(!inboundNode["AverageRingTime"].isNull())
+			dataObject.inbound.averageRingTime = std::stof(inboundNode["AverageRingTime"].asString());
+		if(!inboundNode["AverageTalkTime"].isNull())
+			dataObject.inbound.averageTalkTime = std::stof(inboundNode["AverageTalkTime"].asString());
+		if(!inboundNode["AverageWaitTime"].isNull())
+			dataObject.inbound.averageWaitTime = std::stof(inboundNode["AverageWaitTime"].asString());
+		if(!inboundNode["AverageWorkTime"].isNull())
+			dataObject.inbound.averageWorkTime = std::stof(inboundNode["AverageWorkTime"].asString());
+		if(!inboundNode["CallsAbandoned"].isNull())
+			dataObject.inbound.callsAbandoned = std::stol(inboundNode["CallsAbandoned"].asString());
+		if(!inboundNode["CallsAbandonedInQueue"].isNull())
+			dataObject.inbound.callsAbandonedInQueue = std::stol(inboundNode["CallsAbandonedInQueue"].asString());
+		if(!inboundNode["CallsAbandonedInRinging"].isNull())
+			dataObject.inbound.callsAbandonedInRinging = std::stol(inboundNode["CallsAbandonedInRinging"].asString());
+		if(!inboundNode["CallsConsulted"].isNull())
+			dataObject.inbound.callsConsulted = std::stol(inboundNode["CallsConsulted"].asString());
+		if(!inboundNode["CallsHandled"].isNull())
+			dataObject.inbound.callsHandled = std::stol(inboundNode["CallsHandled"].asString());
+		if(!inboundNode["CallsHold"].isNull())
+			dataObject.inbound.callsHold = std::stol(inboundNode["CallsHold"].asString());
+		if(!inboundNode["CallsOffered"].isNull())
+			dataObject.inbound.callsOffered = std::stol(inboundNode["CallsOffered"].asString());
+		if(!inboundNode["CallsQueued"].isNull())
+			dataObject.inbound.callsQueued = std::stol(inboundNode["CallsQueued"].asString());
+		if(!inboundNode["CallsRinged"].isNull())
+			dataObject.inbound.callsRinged = std::stol(inboundNode["CallsRinged"].asString());
+		if(!inboundNode["CallsTransferred"].isNull())
+			dataObject.inbound.callsTransferred = std::stol(inboundNode["CallsTransferred"].asString());
+		if(!inboundNode["HandleRate"].isNull())
+			dataObject.inbound.handleRate = std::stof(inboundNode["HandleRate"].asString());
+		if(!inboundNode["MaxAbandonTime"].isNull())
+			dataObject.inbound.maxAbandonTime = std::stol(inboundNode["MaxAbandonTime"].asString());
+		if(!inboundNode["MaxAbandonedInQueueTime"].isNull())
+			dataObject.inbound.maxAbandonedInQueueTime = std::stol(inboundNode["MaxAbandonedInQueueTime"].asString());
+		if(!inboundNode["MaxAbandonedInRingTime"].isNull())
+			dataObject.inbound.maxAbandonedInRingTime = std::stol(inboundNode["MaxAbandonedInRingTime"].asString());
+		if(!inboundNode["MaxRingTime"].isNull())
+			dataObject.inbound.maxRingTime = std::stol(inboundNode["MaxRingTime"].asString());
+		if(!inboundNode["MaxTalkTime"].isNull())
+			dataObject.inbound.maxTalkTime = std::stol(inboundNode["MaxTalkTime"].asString());
+		if(!inboundNode["MaxWaitTime"].isNull())
+			dataObject.inbound.maxWaitTime = std::stol(inboundNode["MaxWaitTime"].asString());
+		if(!inboundNode["MaxWorkTime"].isNull())
+			dataObject.inbound.maxWorkTime = std::stol(inboundNode["MaxWorkTime"].asString());
+		if(!inboundNode["SatisfactionIndex"].isNull())
+			dataObject.inbound.satisfactionIndex = std::stof(inboundNode["SatisfactionIndex"].asString());
+		if(!inboundNode["SatisfactionSurveysOffered"].isNull())
+			dataObject.inbound.satisfactionSurveysOffered = std::stol(inboundNode["SatisfactionSurveysOffered"].asString());
+		if(!inboundNode["SatisfactionSurveysResponded"].isNull())
+			dataObject.inbound.satisfactionSurveysResponded = std::stol(inboundNode["SatisfactionSurveysResponded"].asString());
+		if(!inboundNode["ServiceLevel20"].isNull())
+			dataObject.inbound.serviceLevel20 = std::stof(inboundNode["ServiceLevel20"].asString());
+		if(!inboundNode["TotalAbandonTime"].isNull())
+			dataObject.inbound.totalAbandonTime = std::stol(inboundNode["TotalAbandonTime"].asString());
+		if(!inboundNode["TotalAbandonedInQueueTime"].isNull())
+			dataObject.inbound.totalAbandonedInQueueTime = std::stol(inboundNode["TotalAbandonedInQueueTime"].asString());
+		if(!inboundNode["TotalAbandonedInRingTime"].isNull())
+			dataObject.inbound.totalAbandonedInRingTime = std::stol(inboundNode["TotalAbandonedInRingTime"].asString());
+		if(!inboundNode["TotalHoldTime"].isNull())
+			dataObject.inbound.totalHoldTime = std::stol(inboundNode["TotalHoldTime"].asString());
+		if(!inboundNode["TotalRingTime"].isNull())
+			dataObject.inbound.totalRingTime = std::stol(inboundNode["TotalRingTime"].asString());
+		if(!inboundNode["TotalTalkTime"].isNull())
+			dataObject.inbound.totalTalkTime = std::stol(inboundNode["TotalTalkTime"].asString());
+		if(!inboundNode["TotalWaitTime"].isNull())
+			dataObject.inbound.totalWaitTime = std::stol(inboundNode["TotalWaitTime"].asString());
+		if(!inboundNode["TotalWorkTime"].isNull())
+			dataObject.inbound.totalWorkTime = std::stol(inboundNode["TotalWorkTime"].asString());
+		auto outboundNode = value["Outbound"];
+		if(!outboundNode["AnswerRate"].isNull())
+			dataObject.outbound.answerRate = std::stof(outboundNode["AnswerRate"].asString());
+		if(!outboundNode["AverageDialingTime"].isNull())
+			dataObject.outbound.averageDialingTime = std::stof(outboundNode["AverageDialingTime"].asString());
+		if(!outboundNode["AverageTalkTime"].isNull())
+			dataObject.outbound.averageTalkTime = std::stof(outboundNode["AverageTalkTime"].asString());
+		if(!outboundNode["AverageWorkTime"].isNull())
+			dataObject.outbound.averageWorkTime = std::stof(outboundNode["AverageWorkTime"].asString());
+		if(!outboundNode["CallsAnswered"].isNull())
+			dataObject.outbound.callsAnswered = std::stol(outboundNode["CallsAnswered"].asString());
+		if(!outboundNode["CallsDialed"].isNull())
+			dataObject.outbound.callsDialed = std::stol(outboundNode["CallsDialed"].asString());
+		if(!outboundNode["MaxDialingTime"].isNull())
+			dataObject.outbound.maxDialingTime = std::stol(outboundNode["MaxDialingTime"].asString());
+		if(!outboundNode["MaxTalkTime"].isNull())
+			dataObject.outbound.maxTalkTime = std::stol(outboundNode["MaxTalkTime"].asString());
+		if(!outboundNode["MaxWorkTime"].isNull())
+			dataObject.outbound.maxWorkTime = std::stol(outboundNode["MaxWorkTime"].asString());
+		if(!outboundNode["SatisfactionIndex"].isNull())
+			dataObject.outbound.satisfactionIndex = std::stof(outboundNode["SatisfactionIndex"].asString());
+		if(!outboundNode["SatisfactionSurveysOffered"].isNull())
+			dataObject.outbound.satisfactionSurveysOffered = std::stol(outboundNode["SatisfactionSurveysOffered"].asString());
+		if(!outboundNode["SatisfactionSurveysResponded"].isNull())
+			dataObject.outbound.satisfactionSurveysResponded = std::stol(outboundNode["SatisfactionSurveysResponded"].asString());
+		if(!outboundNode["TotalDialingTime"].isNull())
+			dataObject.outbound.totalDialingTime = std::stol(outboundNode["TotalDialingTime"].asString());
+		if(!outboundNode["TotalHoldTime"].isNull())
+			dataObject.outbound.totalHoldTime = std::stol(outboundNode["TotalHoldTime"].asString());
+		if(!outboundNode["TotalTalkTime"].isNull())
+			dataObject.outbound.totalTalkTime = std::stol(outboundNode["TotalTalkTime"].asString());
+		if(!outboundNode["TotalWorkTime"].isNull())
+			dataObject.outbound.totalWorkTime = std::stol(outboundNode["TotalWorkTime"].asString());
+		auto overallNode = value["Overall"];
+		if(!overallNode["AverageBreakTime"].isNull())
+			dataObject.overall.averageBreakTime = std::stof(overallNode["AverageBreakTime"].asString());
+		if(!overallNode["AverageReadyTime"].isNull())
+			dataObject.overall.averageReadyTime = std::stof(overallNode["AverageReadyTime"].asString());
+		if(!overallNode["AverageTalkTime"].isNull())
+			dataObject.overall.averageTalkTime = std::stof(overallNode["AverageTalkTime"].asString());
+		if(!overallNode["AverageWorkTime"].isNull())
+			dataObject.overall.averageWorkTime = std::stof(overallNode["AverageWorkTime"].asString());
+		if(!overallNode["MaxBreakTime"].isNull())
+			dataObject.overall.maxBreakTime = std::stol(overallNode["MaxBreakTime"].asString());
+		if(!overallNode["MaxReadyTime"].isNull())
+			dataObject.overall.maxReadyTime = std::stol(overallNode["MaxReadyTime"].asString());
+		if(!overallNode["MaxTalkTime"].isNull())
+			dataObject.overall.maxTalkTime = std::stol(overallNode["MaxTalkTime"].asString());
+		if(!overallNode["MaxWorkTime"].isNull())
+			dataObject.overall.maxWorkTime = std::stol(overallNode["MaxWorkTime"].asString());
+		if(!overallNode["OccupancyRate"].isNull())
+			dataObject.overall.occupancyRate = std::stof(overallNode["OccupancyRate"].asString());
+		if(!overallNode["SatisfactionIndex"].isNull())
+			dataObject.overall.satisfactionIndex = std::stof(overallNode["SatisfactionIndex"].asString());
+		if(!overallNode["SatisfactionSurveysOffered"].isNull())
+			dataObject.overall.satisfactionSurveysOffered = std::stol(overallNode["SatisfactionSurveysOffered"].asString());
+		if(!overallNode["SatisfactionSurveysResponded"].isNull())
+			dataObject.overall.satisfactionSurveysResponded = std::stol(overallNode["SatisfactionSurveysResponded"].asString());
+		if(!overallNode["TotalBreakTime"].isNull())
+			dataObject.overall.totalBreakTime = std::stol(overallNode["TotalBreakTime"].asString());
+		if(!overallNode["TotalCalls"].isNull())
+			dataObject.overall.totalCalls = std::stol(overallNode["TotalCalls"].asString());
+		if(!overallNode["TotalHoldTime"].isNull())
+			dataObject.overall.totalHoldTime = std::stol(overallNode["TotalHoldTime"].asString());
+		if(!overallNode["TotalLoggedInTime"].isNull())
+			dataObject.overall.totalLoggedInTime = std::stol(overallNode["TotalLoggedInTime"].asString());
+		if(!overallNode["TotalReadyTime"].isNull())
+			dataObject.overall.totalReadyTime = std::stol(overallNode["TotalReadyTime"].asString());
+		if(!overallNode["TotalTalkTime"].isNull())
+			dataObject.overall.totalTalkTime = std::stol(overallNode["TotalTalkTime"].asString());
+		if(!overallNode["TotalWorkTime"].isNull())
+			dataObject.overall.totalWorkTime = std::stol(overallNode["TotalWorkTime"].asString());
+		data_.push_back(dataObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ListIntervalSkillGroupReportResult::getMessage()const
+{
+	return message_;
+}
+
+int ListIntervalSkillGroupReportResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+std::vector<ListIntervalSkillGroupReportResult::DataItem> ListIntervalSkillGroupReportResult::getData()const
+{
+	return data_;
+}
+
+std::string ListIntervalSkillGroupReportResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/ListIvrTrackingDetailsRequest.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/ccc/model/ListIvrTrackingDetailsRequest.h>
+
+using AlibabaCloud::CCC::Model::ListIvrTrackingDetailsRequest;
+
+ListIvrTrackingDetailsRequest::ListIvrTrackingDetailsRequest() :
+	RpcServiceRequest("ccc", "2020-07-01", "ListIvrTrackingDetails")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListIvrTrackingDetailsRequest::~ListIvrTrackingDetailsRequest()
+{}
+
+std::string ListIvrTrackingDetailsRequest::getContactId()const
+{
+	return contactId_;
+}
+
+void ListIvrTrackingDetailsRequest::setContactId(const std::string& contactId)
+{
+	contactId_ = contactId;
+	setParameter("ContactId", contactId);
+}
+
+int ListIvrTrackingDetailsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListIvrTrackingDetailsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string ListIvrTrackingDetailsRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void ListIvrTrackingDetailsRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+int ListIvrTrackingDetailsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListIvrTrackingDetailsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

ccc/src/model/ListIvrTrackingDetailsResult.cc

@@ -0,0 +1,115 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ccc/model/ListIvrTrackingDetailsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+ListIvrTrackingDetailsResult::ListIvrTrackingDetailsResult() :
+	ServiceResult()
+{}
+
+ListIvrTrackingDetailsResult::ListIvrTrackingDetailsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListIvrTrackingDetailsResult::~ListIvrTrackingDetailsResult()
+{}
+
+void ListIvrTrackingDetailsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["PageNumber"].isNull())
+		data_.pageNumber = std::stoi(dataNode["PageNumber"].asString());
+	if(!dataNode["PageSize"].isNull())
+		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	if(!dataNode["TotalCount"].isNull())
+		data_.totalCount = std::stoi(dataNode["TotalCount"].asString());
+	auto allListNode = dataNode["List"]["IvrTracking"];
+	for (auto dataNodeListIvrTracking : allListNode)
+	{
+		Data::IvrTracking ivrTrackingObject;
+		if(!dataNodeListIvrTracking["Callee"].isNull())
+			ivrTrackingObject.callee = dataNodeListIvrTracking["Callee"].asString();
+		if(!dataNodeListIvrTracking["Caller"].isNull())
+			ivrTrackingObject.caller = dataNodeListIvrTracking["Caller"].asString();
+		if(!dataNodeListIvrTracking["ChannelId"].isNull())
+			ivrTrackingObject.channelId = dataNodeListIvrTracking["ChannelId"].asString();
+		if(!dataNodeListIvrTracking["ChannelVariables"].isNull())
+			ivrTrackingObject.channelVariables = dataNodeListIvrTracking["ChannelVariables"].asString();
+		if(!dataNodeListIvrTracking["ContactId"].isNull())
+			ivrTrackingObject.contactId = dataNodeListIvrTracking["ContactId"].asString();
+		if(!dataNodeListIvrTracking["EnterTime"].isNull())
+			ivrTrackingObject.enterTime = std::stol(dataNodeListIvrTracking["EnterTime"].asString());
+		if(!dataNodeListIvrTracking["FlowId"].isNull())
+			ivrTrackingObject.flowId = dataNodeListIvrTracking["FlowId"].asString();
+		if(!dataNodeListIvrTracking["FlowName"].isNull())
+			ivrTrackingObject.flowName = dataNodeListIvrTracking["FlowName"].asString();
+		if(!dataNodeListIvrTracking["Instance"].isNull())
+			ivrTrackingObject.instance = dataNodeListIvrTracking["Instance"].asString();
+		if(!dataNodeListIvrTracking["LeaveTime"].isNull())
+			ivrTrackingObject.leaveTime = std::stol(dataNodeListIvrTracking["LeaveTime"].asString());
+		if(!dataNodeListIvrTracking["NodeExitCode"].isNull())
+			ivrTrackingObject.nodeExitCode = dataNodeListIvrTracking["NodeExitCode"].asString();
+		if(!dataNodeListIvrTracking["NodeId"].isNull())
+			ivrTrackingObject.nodeId = dataNodeListIvrTracking["NodeId"].asString();
+		if(!dataNodeListIvrTracking["NodeName"].isNull())
+			ivrTrackingObject.nodeName = dataNodeListIvrTracking["NodeName"].asString();
+		if(!dataNodeListIvrTracking["NodeProperties"].isNull())
+			ivrTrackingObject.nodeProperties = dataNodeListIvrTracking["NodeProperties"].asString();
+		if(!dataNodeListIvrTracking["NodeType"].isNull())
+			ivrTrackingObject.nodeType = dataNodeListIvrTracking["NodeType"].asString();
+		if(!dataNodeListIvrTracking["NodeVariables"].isNull())
+			ivrTrackingObject.nodeVariables = dataNodeListIvrTracking["NodeVariables"].asString();
+		data_.list.push_back(ivrTrackingObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ListIvrTrackingDetailsResult::getMessage()const
+{
+	return message_;
+}
+
+int ListIvrTrackingDetailsResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+ListIvrTrackingDetailsResult::Data ListIvrTrackingDetailsResult::getData()const
+{
+	return data_;
+}
+
+std::string ListIvrTrackingDetailsResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/ListRealtimeSkillGroupStatesRequest.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/ccc/model/ListRealtimeSkillGroupStatesRequest.h>
+
+using AlibabaCloud::CCC::Model::ListRealtimeSkillGroupStatesRequest;
+
+ListRealtimeSkillGroupStatesRequest::ListRealtimeSkillGroupStatesRequest() :
+	RpcServiceRequest("ccc", "2020-07-01", "ListRealtimeSkillGroupStates")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ListRealtimeSkillGroupStatesRequest::~ListRealtimeSkillGroupStatesRequest()
+{}
+
+int ListRealtimeSkillGroupStatesRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void ListRealtimeSkillGroupStatesRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string ListRealtimeSkillGroupStatesRequest::getSkillGroupIdList()const
+{
+	return skillGroupIdList_;
+}
+
+void ListRealtimeSkillGroupStatesRequest::setSkillGroupIdList(const std::string& skillGroupIdList)
+{
+	skillGroupIdList_ = skillGroupIdList;
+	setBodyParameter("SkillGroupIdList", skillGroupIdList);
+}
+
+std::string ListRealtimeSkillGroupStatesRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void ListRealtimeSkillGroupStatesRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+int ListRealtimeSkillGroupStatesRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void ListRealtimeSkillGroupStatesRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+

ccc/src/model/ListRealtimeSkillGroupStatesResult.cc

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/ccc/model/ListRealtimeSkillGroupStatesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::CCC;
+using namespace AlibabaCloud::CCC::Model;
+
+ListRealtimeSkillGroupStatesResult::ListRealtimeSkillGroupStatesResult() :
+	ServiceResult()
+{}
+
+ListRealtimeSkillGroupStatesResult::ListRealtimeSkillGroupStatesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ListRealtimeSkillGroupStatesResult::~ListRealtimeSkillGroupStatesResult()
+{}
+
+void ListRealtimeSkillGroupStatesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["PageNumber"].isNull())
+		data_.pageNumber = std::stoi(dataNode["PageNumber"].asString());
+	if(!dataNode["PageSize"].isNull())
+		data_.pageSize = std::stoi(dataNode["PageSize"].asString());
+	if(!dataNode["TotalCount"].isNull())
+		data_.totalCount = std::stoi(dataNode["TotalCount"].asString());
+	auto allListNode = dataNode["List"]["SkillGroupState"];
+	for (auto dataNodeListSkillGroupState : allListNode)
+	{
+		Data::SkillGroupState skillGroupStateObject;
+		if(!dataNodeListSkillGroupState["BreakingAgents"].isNull())
+			skillGroupStateObject.breakingAgents = std::stol(dataNodeListSkillGroupState["BreakingAgents"].asString());
+		if(!dataNodeListSkillGroupState["InstanceId"].isNull())
+			skillGroupStateObject.instanceId = dataNodeListSkillGroupState["InstanceId"].asString();
+		if(!dataNodeListSkillGroupState["LoggedInAgents"].isNull())
+			skillGroupStateObject.loggedInAgents = std::stol(dataNodeListSkillGroupState["LoggedInAgents"].asString());
+		if(!dataNodeListSkillGroupState["LongestWaitingTime"].isNull())
+			skillGroupStateObject.longestWaitingTime = std::stol(dataNodeListSkillGroupState["LongestWaitingTime"].asString());
+		if(!dataNodeListSkillGroupState["ReadyAgents"].isNull())
+			skillGroupStateObject.readyAgents = std::stol(dataNodeListSkillGroupState["ReadyAgents"].asString());
+		if(!dataNodeListSkillGroupState["SkillGroupId"].isNull())
+			skillGroupStateObject.skillGroupId = dataNodeListSkillGroupState["SkillGroupId"].asString();
+		if(!dataNodeListSkillGroupState["SkillGroupName"].isNull())
+			skillGroupStateObject.skillGroupName = dataNodeListSkillGroupState["SkillGroupName"].asString();
+		if(!dataNodeListSkillGroupState["TalkingAgents"].isNull())
+			skillGroupStateObject.talkingAgents = std::stol(dataNodeListSkillGroupState["TalkingAgents"].asString());
+		if(!dataNodeListSkillGroupState["WaitingCalls"].isNull())
+			skillGroupStateObject.waitingCalls = std::stol(dataNodeListSkillGroupState["WaitingCalls"].asString());
+		if(!dataNodeListSkillGroupState["WorkingAgents"].isNull())
+			skillGroupStateObject.workingAgents = std::stol(dataNodeListSkillGroupState["WorkingAgents"].asString());
+		data_.list.push_back(skillGroupStateObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["HttpStatusCode"].isNull())
+		httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string ListRealtimeSkillGroupStatesResult::getMessage()const
+{
+	return message_;
+}
+
+int ListRealtimeSkillGroupStatesResult::getHttpStatusCode()const
+{
+	return httpStatusCode_;
+}
+
+ListRealtimeSkillGroupStatesResult::Data ListRealtimeSkillGroupStatesResult::getData()const
+{
+	return data_;
+}
+
+std::string ListRealtimeSkillGroupStatesResult::getCode()const
+{
+	return code_;
+}
+

ccc/src/model/ListUsersResult.cc

@@ -66,6 +66,8 @@ void ListUsersResult::parse(const std::string &payload)
 			userDetailObject.userId = dataNodeListUserDetail["UserId"].asString();
 		if(!dataNodeListUserDetail["WorkMode"].isNull())
 			userDetailObject.workMode = dataNodeListUserDetail["WorkMode"].asString();
+		if(!dataNodeListUserDetail["PrimaryAccount"].isNull())
+			userDetailObject.primaryAccount = dataNodeListUserDetail["PrimaryAccount"].asString() == "true";
 		auto allPersonalOutboundNumberListNode = dataNodeListUserDetail["PersonalOutboundNumberList"]["PhoneNumber"];
 		for (auto dataNodeListUserDetailPersonalOutboundNumberListPhoneNumber : allPersonalOutboundNumberListNode)
 		{

dataworks-public/CMakeLists.txt

@@ -395,6 +395,10 @@ set(dataworks-public_public_header_model
 	include/alibabacloud/dataworks-public/model/UpdateMetaTableResult.h
 	include/alibabacloud/dataworks-public/model/UpdateMetaTableIntroWikiRequest.h
 	include/alibabacloud/dataworks-public/model/UpdateMetaTableIntroWikiResult.h
+	include/alibabacloud/dataworks-public/model/UpdateNodeOwnerRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateNodeOwnerResult.h
+	include/alibabacloud/dataworks-public/model/UpdateNodeRunModeRequest.h
+	include/alibabacloud/dataworks-public/model/UpdateNodeRunModeResult.h
 	include/alibabacloud/dataworks-public/model/UpdateQualityFollowerRequest.h
 	include/alibabacloud/dataworks-public/model/UpdateQualityFollowerResult.h
 	include/alibabacloud/dataworks-public/model/UpdateQualityRuleRequest.h
@@ -790,6 +794,10 @@ set(dataworks-public_src
 	src/model/UpdateMetaTableResult.cc
 	src/model/UpdateMetaTableIntroWikiRequest.cc
 	src/model/UpdateMetaTableIntroWikiResult.cc
+	src/model/UpdateNodeOwnerRequest.cc
+	src/model/UpdateNodeOwnerResult.cc
+	src/model/UpdateNodeRunModeRequest.cc
+	src/model/UpdateNodeRunModeResult.cc
 	src/model/UpdateQualityFollowerRequest.cc
 	src/model/UpdateQualityFollowerResult.cc
 	src/model/UpdateQualityRuleRequest.cc

dataworks-public/include/alibabacloud/dataworks-public/Dataworks_publicClient.h

@@ -396,6 +396,10 @@
 #include "model/UpdateMetaTableResult.h"
 #include "model/UpdateMetaTableIntroWikiRequest.h"
 #include "model/UpdateMetaTableIntroWikiResult.h"
+#include "model/UpdateNodeOwnerRequest.h"
+#include "model/UpdateNodeOwnerResult.h"
+#include "model/UpdateNodeRunModeRequest.h"
+#include "model/UpdateNodeRunModeResult.h"
 #include "model/UpdateQualityFollowerRequest.h"
 #include "model/UpdateQualityFollowerResult.h"
 #include "model/UpdateQualityRuleRequest.h"
@@ -984,6 +988,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::UpdateMetaTableIntroWikiResult> UpdateMetaTableIntroWikiOutcome;
 			typedef std::future<UpdateMetaTableIntroWikiOutcome> UpdateMetaTableIntroWikiOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateMetaTableIntroWikiRequest&, const UpdateMetaTableIntroWikiOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateMetaTableIntroWikiAsyncHandler;
+			typedef Outcome<Error, Model::UpdateNodeOwnerResult> UpdateNodeOwnerOutcome;
+			typedef std::future<UpdateNodeOwnerOutcome> UpdateNodeOwnerOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateNodeOwnerRequest&, const UpdateNodeOwnerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateNodeOwnerAsyncHandler;
+			typedef Outcome<Error, Model::UpdateNodeRunModeResult> UpdateNodeRunModeOutcome;
+			typedef std::future<UpdateNodeRunModeOutcome> UpdateNodeRunModeOutcomeCallable;
+			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateNodeRunModeRequest&, const UpdateNodeRunModeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateNodeRunModeAsyncHandler;
 			typedef Outcome<Error, Model::UpdateQualityFollowerResult> UpdateQualityFollowerOutcome;
 			typedef std::future<UpdateQualityFollowerOutcome> UpdateQualityFollowerOutcomeCallable;
 			typedef std::function<void(const Dataworks_publicClient*, const Model::UpdateQualityFollowerRequest&, const UpdateQualityFollowerOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateQualityFollowerAsyncHandler;
@@ -1577,6 +1587,12 @@ namespace AlibabaCloud
 			UpdateMetaTableIntroWikiOutcome updateMetaTableIntroWiki(const Model::UpdateMetaTableIntroWikiRequest &request)const;
 			void updateMetaTableIntroWikiAsync(const Model::UpdateMetaTableIntroWikiRequest& request, const UpdateMetaTableIntroWikiAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateMetaTableIntroWikiOutcomeCallable updateMetaTableIntroWikiCallable(const Model::UpdateMetaTableIntroWikiRequest& request) const;
+			UpdateNodeOwnerOutcome updateNodeOwner(const Model::UpdateNodeOwnerRequest &request)const;
+			void updateNodeOwnerAsync(const Model::UpdateNodeOwnerRequest& request, const UpdateNodeOwnerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateNodeOwnerOutcomeCallable updateNodeOwnerCallable(const Model::UpdateNodeOwnerRequest& request) const;
+			UpdateNodeRunModeOutcome updateNodeRunMode(const Model::UpdateNodeRunModeRequest &request)const;
+			void updateNodeRunModeAsync(const Model::UpdateNodeRunModeRequest& request, const UpdateNodeRunModeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			UpdateNodeRunModeOutcomeCallable updateNodeRunModeCallable(const Model::UpdateNodeRunModeRequest& request) const;
 			UpdateQualityFollowerOutcome updateQualityFollower(const Model::UpdateQualityFollowerRequest &request)const;
 			void updateQualityFollowerAsync(const Model::UpdateQualityFollowerRequest& request, const UpdateQualityFollowerAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			UpdateQualityFollowerOutcomeCallable updateQualityFollowerCallable(const Model::UpdateQualityFollowerRequest& request) const;

dataworks-public/include/alibabacloud/dataworks-public/model/CreateFileRequest.h

@@ -81,6 +81,8 @@ namespace AlibabaCloud
 				void setFileFolderPath(const std::string& fileFolderPath);
 				std::string getFileDescription()const;
 				void setFileDescription(const std::string& fileDescription);
+				bool getAutoParsing()const;
+				void setAutoParsing(bool autoParsing);
 
             private:
 				int fileType_;
@@ -106,6 +108,7 @@ namespace AlibabaCloud
 				std::string dependentType_;
 				std::string fileFolderPath_;
 				std::string fileDescription_;
+				bool autoParsing_;
 
 			};
 		}

dataworks-public/include/alibabacloud/dataworks-public/model/GetFileResult.h

@@ -53,6 +53,7 @@ namespace AlibabaCloud
 						long nodeId;
 						int commitStatus;
 						std::string deletedStatus;
+						bool autoParsing;
 						std::string fileFolderId;
 						long bizId;
 						long businessId;
@@ -62,6 +63,7 @@ namespace AlibabaCloud
 						struct NodeInputOutput
 						{
 							std::string input;
+							std::string parseType;
 						};
 						struct NodeInputOutput1
 						{