Add new API DescribeGrantRulesToResource .

VERSION

@@ -1 +1 @@
-1.36.1276
+1.36.1277

cbn/CMakeLists.txt

@@ -47,6 +47,8 @@ set(cbn_public_header_model
 	include/alibabacloud/cbn/model/CreateCenChildInstanceRouteEntryToCenResult.h
 	include/alibabacloud/cbn/model/CreateCenInterRegionTrafficQosPolicyRequest.h
 	include/alibabacloud/cbn/model/CreateCenInterRegionTrafficQosPolicyResult.h
+	include/alibabacloud/cbn/model/CreateCenInterRegionTrafficQosQueueRequest.h
+	include/alibabacloud/cbn/model/CreateCenInterRegionTrafficQosQueueResult.h
 	include/alibabacloud/cbn/model/CreateCenRouteMapRequest.h
 	include/alibabacloud/cbn/model/CreateCenRouteMapResult.h
 	include/alibabacloud/cbn/model/CreateFlowlogRequest.h
@@ -149,6 +151,8 @@ set(cbn_public_header_model
 	include/alibabacloud/cbn/model/DescribeGeographicRegionMembershipResult.h
 	include/alibabacloud/cbn/model/DescribeGrantRulesToCenRequest.h
 	include/alibabacloud/cbn/model/DescribeGrantRulesToCenResult.h
+	include/alibabacloud/cbn/model/DescribeGrantRulesToResourceRequest.h
+	include/alibabacloud/cbn/model/DescribeGrantRulesToResourceResult.h
 	include/alibabacloud/cbn/model/DescribePublishedRouteEntriesRequest.h
 	include/alibabacloud/cbn/model/DescribePublishedRouteEntriesResult.h
 	include/alibabacloud/cbn/model/DescribeRouteConflictRequest.h
@@ -237,6 +241,8 @@ set(cbn_public_header_model
 	include/alibabacloud/cbn/model/RegisterTransitRouterMulticastGroupMembersResult.h
 	include/alibabacloud/cbn/model/RegisterTransitRouterMulticastGroupSourcesRequest.h
 	include/alibabacloud/cbn/model/RegisterTransitRouterMulticastGroupSourcesResult.h
+	include/alibabacloud/cbn/model/RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest.h
+	include/alibabacloud/cbn/model/RemoveTrafficMatchRuleFromTrafficMarkingPolicyResult.h
 	include/alibabacloud/cbn/model/RemoveTraficMatchRuleFromTrafficMarkingPolicyRequest.h
 	include/alibabacloud/cbn/model/RemoveTraficMatchRuleFromTrafficMarkingPolicyResult.h
 	include/alibabacloud/cbn/model/ReplaceTransitRouterRouteTableAssociationRequest.h
@@ -312,6 +318,8 @@ set(cbn_src
 	src/model/CreateCenChildInstanceRouteEntryToCenResult.cc
 	src/model/CreateCenInterRegionTrafficQosPolicyRequest.cc
 	src/model/CreateCenInterRegionTrafficQosPolicyResult.cc
+	src/model/CreateCenInterRegionTrafficQosQueueRequest.cc
+	src/model/CreateCenInterRegionTrafficQosQueueResult.cc
 	src/model/CreateCenRouteMapRequest.cc
 	src/model/CreateCenRouteMapResult.cc
 	src/model/CreateFlowlogRequest.cc
@@ -414,6 +422,8 @@ set(cbn_src
 	src/model/DescribeGeographicRegionMembershipResult.cc
 	src/model/DescribeGrantRulesToCenRequest.cc
 	src/model/DescribeGrantRulesToCenResult.cc
+	src/model/DescribeGrantRulesToResourceRequest.cc
+	src/model/DescribeGrantRulesToResourceResult.cc
 	src/model/DescribePublishedRouteEntriesRequest.cc
 	src/model/DescribePublishedRouteEntriesResult.cc
 	src/model/DescribeRouteConflictRequest.cc
@@ -502,6 +512,8 @@ set(cbn_src
 	src/model/RegisterTransitRouterMulticastGroupMembersResult.cc
 	src/model/RegisterTransitRouterMulticastGroupSourcesRequest.cc
 	src/model/RegisterTransitRouterMulticastGroupSourcesResult.cc
+	src/model/RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest.cc
+	src/model/RemoveTrafficMatchRuleFromTrafficMarkingPolicyResult.cc
 	src/model/RemoveTraficMatchRuleFromTrafficMarkingPolicyRequest.cc
 	src/model/RemoveTraficMatchRuleFromTrafficMarkingPolicyResult.cc
 	src/model/ReplaceTransitRouterRouteTableAssociationRequest.cc

cbn/include/alibabacloud/cbn/CbnClient.h

@@ -48,6 +48,8 @@
 #include "model/CreateCenChildInstanceRouteEntryToCenResult.h"
 #include "model/CreateCenInterRegionTrafficQosPolicyRequest.h"
 #include "model/CreateCenInterRegionTrafficQosPolicyResult.h"
+#include "model/CreateCenInterRegionTrafficQosQueueRequest.h"
+#include "model/CreateCenInterRegionTrafficQosQueueResult.h"
 #include "model/CreateCenRouteMapRequest.h"
 #include "model/CreateCenRouteMapResult.h"
 #include "model/CreateFlowlogRequest.h"
@@ -150,6 +152,8 @@
 #include "model/DescribeGeographicRegionMembershipResult.h"
 #include "model/DescribeGrantRulesToCenRequest.h"
 #include "model/DescribeGrantRulesToCenResult.h"
+#include "model/DescribeGrantRulesToResourceRequest.h"
+#include "model/DescribeGrantRulesToResourceResult.h"
 #include "model/DescribePublishedRouteEntriesRequest.h"
 #include "model/DescribePublishedRouteEntriesResult.h"
 #include "model/DescribeRouteConflictRequest.h"
@@ -238,6 +242,8 @@
 #include "model/RegisterTransitRouterMulticastGroupMembersResult.h"
 #include "model/RegisterTransitRouterMulticastGroupSourcesRequest.h"
 #include "model/RegisterTransitRouterMulticastGroupSourcesResult.h"
+#include "model/RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest.h"
+#include "model/RemoveTrafficMatchRuleFromTrafficMarkingPolicyResult.h"
 #include "model/RemoveTraficMatchRuleFromTrafficMarkingPolicyRequest.h"
 #include "model/RemoveTraficMatchRuleFromTrafficMarkingPolicyResult.h"
 #include "model/ReplaceTransitRouterRouteTableAssociationRequest.h"
@@ -332,6 +338,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CreateCenInterRegionTrafficQosPolicyResult> CreateCenInterRegionTrafficQosPolicyOutcome;
 			typedef std::future<CreateCenInterRegionTrafficQosPolicyOutcome> CreateCenInterRegionTrafficQosPolicyOutcomeCallable;
 			typedef std::function<void(const CbnClient*, const Model::CreateCenInterRegionTrafficQosPolicyRequest&, const CreateCenInterRegionTrafficQosPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCenInterRegionTrafficQosPolicyAsyncHandler;
+			typedef Outcome<Error, Model::CreateCenInterRegionTrafficQosQueueResult> CreateCenInterRegionTrafficQosQueueOutcome;
+			typedef std::future<CreateCenInterRegionTrafficQosQueueOutcome> CreateCenInterRegionTrafficQosQueueOutcomeCallable;
+			typedef std::function<void(const CbnClient*, const Model::CreateCenInterRegionTrafficQosQueueRequest&, const CreateCenInterRegionTrafficQosQueueOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCenInterRegionTrafficQosQueueAsyncHandler;
 			typedef Outcome<Error, Model::CreateCenRouteMapResult> CreateCenRouteMapOutcome;
 			typedef std::future<CreateCenRouteMapOutcome> CreateCenRouteMapOutcomeCallable;
 			typedef std::function<void(const CbnClient*, const Model::CreateCenRouteMapRequest&, const CreateCenRouteMapOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateCenRouteMapAsyncHandler;
@@ -485,6 +494,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeGrantRulesToCenResult> DescribeGrantRulesToCenOutcome;
 			typedef std::future<DescribeGrantRulesToCenOutcome> DescribeGrantRulesToCenOutcomeCallable;
 			typedef std::function<void(const CbnClient*, const Model::DescribeGrantRulesToCenRequest&, const DescribeGrantRulesToCenOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGrantRulesToCenAsyncHandler;
+			typedef Outcome<Error, Model::DescribeGrantRulesToResourceResult> DescribeGrantRulesToResourceOutcome;
+			typedef std::future<DescribeGrantRulesToResourceOutcome> DescribeGrantRulesToResourceOutcomeCallable;
+			typedef std::function<void(const CbnClient*, const Model::DescribeGrantRulesToResourceRequest&, const DescribeGrantRulesToResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGrantRulesToResourceAsyncHandler;
 			typedef Outcome<Error, Model::DescribePublishedRouteEntriesResult> DescribePublishedRouteEntriesOutcome;
 			typedef std::future<DescribePublishedRouteEntriesOutcome> DescribePublishedRouteEntriesOutcomeCallable;
 			typedef std::function<void(const CbnClient*, const Model::DescribePublishedRouteEntriesRequest&, const DescribePublishedRouteEntriesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePublishedRouteEntriesAsyncHandler;
@@ -617,6 +629,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::RegisterTransitRouterMulticastGroupSourcesResult> RegisterTransitRouterMulticastGroupSourcesOutcome;
 			typedef std::future<RegisterTransitRouterMulticastGroupSourcesOutcome> RegisterTransitRouterMulticastGroupSourcesOutcomeCallable;
 			typedef std::function<void(const CbnClient*, const Model::RegisterTransitRouterMulticastGroupSourcesRequest&, const RegisterTransitRouterMulticastGroupSourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RegisterTransitRouterMulticastGroupSourcesAsyncHandler;
+			typedef Outcome<Error, Model::RemoveTrafficMatchRuleFromTrafficMarkingPolicyResult> RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcome;
+			typedef std::future<RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcome> RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcomeCallable;
+			typedef std::function<void(const CbnClient*, const Model::RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest&, const RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveTrafficMatchRuleFromTrafficMarkingPolicyAsyncHandler;
 			typedef Outcome<Error, Model::RemoveTraficMatchRuleFromTrafficMarkingPolicyResult> RemoveTraficMatchRuleFromTrafficMarkingPolicyOutcome;
 			typedef std::future<RemoveTraficMatchRuleFromTrafficMarkingPolicyOutcome> RemoveTraficMatchRuleFromTrafficMarkingPolicyOutcomeCallable;
 			typedef std::function<void(const CbnClient*, const Model::RemoveTraficMatchRuleFromTrafficMarkingPolicyRequest&, const RemoveTraficMatchRuleFromTrafficMarkingPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveTraficMatchRuleFromTrafficMarkingPolicyAsyncHandler;
@@ -730,6 +745,9 @@ namespace AlibabaCloud
 			CreateCenInterRegionTrafficQosPolicyOutcome createCenInterRegionTrafficQosPolicy(const Model::CreateCenInterRegionTrafficQosPolicyRequest &request)const;
 			void createCenInterRegionTrafficQosPolicyAsync(const Model::CreateCenInterRegionTrafficQosPolicyRequest& request, const CreateCenInterRegionTrafficQosPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateCenInterRegionTrafficQosPolicyOutcomeCallable createCenInterRegionTrafficQosPolicyCallable(const Model::CreateCenInterRegionTrafficQosPolicyRequest& request) const;
+			CreateCenInterRegionTrafficQosQueueOutcome createCenInterRegionTrafficQosQueue(const Model::CreateCenInterRegionTrafficQosQueueRequest &request)const;
+			void createCenInterRegionTrafficQosQueueAsync(const Model::CreateCenInterRegionTrafficQosQueueRequest& request, const CreateCenInterRegionTrafficQosQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateCenInterRegionTrafficQosQueueOutcomeCallable createCenInterRegionTrafficQosQueueCallable(const Model::CreateCenInterRegionTrafficQosQueueRequest& request) const;
 			CreateCenRouteMapOutcome createCenRouteMap(const Model::CreateCenRouteMapRequest &request)const;
 			void createCenRouteMapAsync(const Model::CreateCenRouteMapRequest& request, const CreateCenRouteMapAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CreateCenRouteMapOutcomeCallable createCenRouteMapCallable(const Model::CreateCenRouteMapRequest& request) const;
@@ -883,6 +901,9 @@ namespace AlibabaCloud
 			DescribeGrantRulesToCenOutcome describeGrantRulesToCen(const Model::DescribeGrantRulesToCenRequest &request)const;
 			void describeGrantRulesToCenAsync(const Model::DescribeGrantRulesToCenRequest& request, const DescribeGrantRulesToCenAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeGrantRulesToCenOutcomeCallable describeGrantRulesToCenCallable(const Model::DescribeGrantRulesToCenRequest& request) const;
+			DescribeGrantRulesToResourceOutcome describeGrantRulesToResource(const Model::DescribeGrantRulesToResourceRequest &request)const;
+			void describeGrantRulesToResourceAsync(const Model::DescribeGrantRulesToResourceRequest& request, const DescribeGrantRulesToResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeGrantRulesToResourceOutcomeCallable describeGrantRulesToResourceCallable(const Model::DescribeGrantRulesToResourceRequest& request) const;
 			DescribePublishedRouteEntriesOutcome describePublishedRouteEntries(const Model::DescribePublishedRouteEntriesRequest &request)const;
 			void describePublishedRouteEntriesAsync(const Model::DescribePublishedRouteEntriesRequest& request, const DescribePublishedRouteEntriesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribePublishedRouteEntriesOutcomeCallable describePublishedRouteEntriesCallable(const Model::DescribePublishedRouteEntriesRequest& request) const;
@@ -1015,6 +1036,9 @@ namespace AlibabaCloud
 			RegisterTransitRouterMulticastGroupSourcesOutcome registerTransitRouterMulticastGroupSources(const Model::RegisterTransitRouterMulticastGroupSourcesRequest &request)const;
 			void registerTransitRouterMulticastGroupSourcesAsync(const Model::RegisterTransitRouterMulticastGroupSourcesRequest& request, const RegisterTransitRouterMulticastGroupSourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RegisterTransitRouterMulticastGroupSourcesOutcomeCallable registerTransitRouterMulticastGroupSourcesCallable(const Model::RegisterTransitRouterMulticastGroupSourcesRequest& request) const;
+			RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcome removeTrafficMatchRuleFromTrafficMarkingPolicy(const Model::RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest &request)const;
+			void removeTrafficMatchRuleFromTrafficMarkingPolicyAsync(const Model::RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest& request, const RemoveTrafficMatchRuleFromTrafficMarkingPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcomeCallable removeTrafficMatchRuleFromTrafficMarkingPolicyCallable(const Model::RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest& request) const;
 			RemoveTraficMatchRuleFromTrafficMarkingPolicyOutcome removeTraficMatchRuleFromTrafficMarkingPolicy(const Model::RemoveTraficMatchRuleFromTrafficMarkingPolicyRequest &request)const;
 			void removeTraficMatchRuleFromTrafficMarkingPolicyAsync(const Model::RemoveTraficMatchRuleFromTrafficMarkingPolicyRequest& request, const RemoveTraficMatchRuleFromTrafficMarkingPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			RemoveTraficMatchRuleFromTrafficMarkingPolicyOutcomeCallable removeTraficMatchRuleFromTrafficMarkingPolicyCallable(const Model::RemoveTraficMatchRuleFromTrafficMarkingPolicyRequest& request) const;

cbn/include/alibabacloud/cbn/model/CreateCenInterRegionTrafficQosQueueRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CBN_MODEL_CREATECENINTERREGIONTRAFFICQOSQUEUEREQUEST_H_
+#define ALIBABACLOUD_CBN_MODEL_CREATECENINTERREGIONTRAFFICQOSQUEUEREQUEST_H_
+
+#include <alibabacloud/cbn/CbnExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cbn {
+namespace Model {
+class ALIBABACLOUD_CBN_EXPORT CreateCenInterRegionTrafficQosQueueRequest : public RpcServiceRequest {
+public:
+	CreateCenInterRegionTrafficQosQueueRequest();
+	~CreateCenInterRegionTrafficQosQueueRequest();
+	std::vector<int> getDscps() const;
+	void setDscps(const std::vector<int> &dscps);
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getQosQueueName() const;
+	void setQosQueueName(const std::string &qosQueueName);
+	std::string getRemainBandwidthPercent() const;
+	void setRemainBandwidthPercent(const std::string &remainBandwidthPercent);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getTrafficQosPolicyId() const;
+	void setTrafficQosPolicyId(const std::string &trafficQosPolicyId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	std::string getQosQueueDescription() const;
+	void setQosQueueDescription(const std::string &qosQueueDescription);
+
+private:
+	std::vector<int> dscps_;
+	long resourceOwnerId_;
+	std::string clientToken_;
+	std::string qosQueueName_;
+	std::string remainBandwidthPercent_;
+	bool dryRun_;
+	std::string trafficQosPolicyId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+	std::string qosQueueDescription_;
+};
+} // namespace Model
+} // namespace Cbn
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CBN_MODEL_CREATECENINTERREGIONTRAFFICQOSQUEUEREQUEST_H_

cbn/include/alibabacloud/cbn/model/CreateCenInterRegionTrafficQosQueueResult.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_CBN_MODEL_CREATECENINTERREGIONTRAFFICQOSQUEUERESULT_H_
+#define ALIBABACLOUD_CBN_MODEL_CREATECENINTERREGIONTRAFFICQOSQUEUERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cbn/CbnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cbn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CBN_EXPORT CreateCenInterRegionTrafficQosQueueResult : public ServiceResult
+			{
+			public:
+
+
+				CreateCenInterRegionTrafficQosQueueResult();
+				explicit CreateCenInterRegionTrafficQosQueueResult(const std::string &payload);
+				~CreateCenInterRegionTrafficQosQueueResult();
+				std::string getQosQueueId()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string qosQueueId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CBN_MODEL_CREATECENINTERREGIONTRAFFICQOSQUEUERESULT_H_

cbn/include/alibabacloud/cbn/model/DescribeGrantRulesToCenRequest.h

@@ -38,21 +38,27 @@ public:
 	void setProductType(const std::string &productType);
 	std::string getRegionId() const;
 	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
 	std::string getResourceOwnerAccount() const;
 	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
 	std::string getOwnerAccount() const;
 	void setOwnerAccount(const std::string &ownerAccount);
 	long getOwnerId() const;
 	void setOwnerId(long ownerId);
+	long getMaxResults() const;
+	void setMaxResults(long maxResults);
 
 private:
 	long resourceOwnerId_;
 	std::string cenId_;
 	std::string productType_;
 	std::string regionId_;
+	std::string nextToken_;
 	std::string resourceOwnerAccount_;
 	std::string ownerAccount_;
 	long ownerId_;
+	long maxResults_;
 };
 } // namespace Model
 } // namespace Cbn

cbn/include/alibabacloud/cbn/model/DescribeGrantRulesToCenResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					std::string childInstanceType;
 					std::string orderType;
+					long cenOwnerId;
 					std::string cenId;
 					long childInstanceOwnerId;
 					std::string childInstanceId;
@@ -46,11 +47,17 @@ namespace AlibabaCloud
 				DescribeGrantRulesToCenResult();
 				explicit DescribeGrantRulesToCenResult(const std::string &payload);
 				~DescribeGrantRulesToCenResult();
+				long getTotalCount()const;
+				std::string getNextToken()const;
+				long getMaxResults()const;
 				std::vector<GrantRule> getGrantRules()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				long totalCount_;
+				std::string nextToken_;
+				long maxResults_;
 				std::vector<GrantRule> grantRules_;
 
 			};

cbn/include/alibabacloud/cbn/model/DescribeGrantRulesToResourceRequest.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_CBN_MODEL_DESCRIBEGRANTRULESTORESOURCEREQUEST_H_
+#define ALIBABACLOUD_CBN_MODEL_DESCRIBEGRANTRULESTORESOURCEREQUEST_H_
+
+#include <alibabacloud/cbn/CbnExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cbn {
+namespace Model {
+class ALIBABACLOUD_CBN_EXPORT DescribeGrantRulesToResourceRequest : public RpcServiceRequest {
+public:
+	DescribeGrantRulesToResourceRequest();
+	~DescribeGrantRulesToResourceRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getProductType() const;
+	void setProductType(const std::string &productType);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNextToken() const;
+	void setNextToken(const std::string &nextToken);
+	std::string getResourceId() const;
+	void setResourceId(const std::string &resourceId);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	int getMaxResults() const;
+	void setMaxResults(int maxResults);
+
+private:
+	long resourceOwnerId_;
+	std::string productType_;
+	std::string regionId_;
+	std::string nextToken_;
+	std::string resourceId_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	long ownerId_;
+	int maxResults_;
+};
+} // namespace Model
+} // namespace Cbn
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CBN_MODEL_DESCRIBEGRANTRULESTORESOURCEREQUEST_H_

cbn/include/alibabacloud/cbn/model/DescribeGrantRulesToResourceResult.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_CBN_MODEL_DESCRIBEGRANTRULESTORESOURCERESULT_H_
+#define ALIBABACLOUD_CBN_MODEL_DESCRIBEGRANTRULESTORESOURCERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cbn/CbnExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cbn
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CBN_EXPORT DescribeGrantRulesToResourceResult : public ServiceResult
+			{
+			public:
+				struct GrantRule
+				{
+					std::string orderType;
+					long cenOwnerId;
+					std::string cenId;
+				};
+
+
+				DescribeGrantRulesToResourceResult();
+				explicit DescribeGrantRulesToResourceResult(const std::string &payload);
+				~DescribeGrantRulesToResourceResult();
+				int getTotalCount()const;
+				std::string getNextToken()const;
+				int getMaxResults()const;
+				std::vector<GrantRule> getGrantRules()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalCount_;
+				std::string nextToken_;
+				int maxResults_;
+				std::vector<GrantRule> grantRules_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CBN_MODEL_DESCRIBEGRANTRULESTORESOURCERESULT_H_

cbn/include/alibabacloud/cbn/model/ListTransitRouterMulticastDomainAssociationsRequest.h

@@ -42,8 +42,6 @@ public:
 	void setNextToken(const std::string &nextToken);
 	std::string getResourceId() const;
 	void setResourceId(const std::string &resourceId);
-	bool getDryRun() const;
-	void setDryRun(bool dryRun);
 	std::string getResourceOwnerAccount() const;
 	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
 	std::string getOwnerAccount() const;
@@ -64,7 +62,6 @@ private:
 	std::string transitRouterMulticastDomainId_;
 	std::string nextToken_;
 	std::string resourceId_;
-	bool dryRun_;
 	std::string resourceOwnerAccount_;
 	std::string ownerAccount_;
 	long ownerId_;

cbn/include/alibabacloud/cbn/model/ListTransitRouterMulticastDomainsRequest.h

@@ -42,8 +42,6 @@ public:
 	void setRegionId(const std::string &regionId);
 	std::string getNextToken() const;
 	void setNextToken(const std::string &nextToken);
-	bool getDryRun() const;
-	void setDryRun(bool dryRun);
 	std::string getResourceOwnerAccount() const;
 	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
 	std::string getOwnerAccount() const;
@@ -62,7 +60,6 @@ private:
 	std::string transitRouterMulticastDomainId_;
 	std::string regionId_;
 	std::string nextToken_;
-	bool dryRun_;
 	std::string resourceOwnerAccount_;
 	std::string ownerAccount_;
 	long ownerId_;

cbn/include/alibabacloud/cbn/model/ListTransitRouterPrefixListAssociationResult.h

@@ -41,6 +41,7 @@ namespace AlibabaCloud
 					long ownerUid;
 					std::string nextHop;
 					std::string nextHopInstanceId;
+					std::string transitRouterId;
 				};
 
 

cbn/include/alibabacloud/cbn/model/RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest.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_CBN_MODEL_REMOVETRAFFICMATCHRULEFROMTRAFFICMARKINGPOLICYREQUEST_H_
+#define ALIBABACLOUD_CBN_MODEL_REMOVETRAFFICMATCHRULEFROMTRAFFICMARKINGPOLICYREQUEST_H_
+
+#include <alibabacloud/cbn/CbnExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Cbn {
+namespace Model {
+class ALIBABACLOUD_CBN_EXPORT RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest : public RpcServiceRequest {
+public:
+	RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest();
+	~RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getTrafficMarkingPolicyId() const;
+	void setTrafficMarkingPolicyId(const std::string &trafficMarkingPolicyId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getResourceOwnerAccount() const;
+	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
+	std::string getOwnerAccount() const;
+	void setOwnerAccount(const std::string &ownerAccount);
+	std::vector<std::string> getTrafficMarkRuleIds() const;
+	void setTrafficMarkRuleIds(const std::vector<std::string> &trafficMarkRuleIds);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+
+private:
+	long resourceOwnerId_;
+	std::string clientToken_;
+	std::string trafficMarkingPolicyId_;
+	bool dryRun_;
+	std::string resourceOwnerAccount_;
+	std::string ownerAccount_;
+	std::vector<std::string> trafficMarkRuleIds_;
+	long ownerId_;
+};
+} // namespace Model
+} // namespace Cbn
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_CBN_MODEL_REMOVETRAFFICMATCHRULEFROMTRAFFICMARKINGPOLICYREQUEST_H_

cbn/include/alibabacloud/cbn/model/RemoveTrafficMatchRuleFromTrafficMarkingPolicyResult.h

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

cbn/src/CbnClient.cc

@@ -519,6 +519,42 @@ CbnClient::CreateCenInterRegionTrafficQosPolicyOutcomeCallable CbnClient::create
 	return task->get_future();
 }
 
+CbnClient::CreateCenInterRegionTrafficQosQueueOutcome CbnClient::createCenInterRegionTrafficQosQueue(const CreateCenInterRegionTrafficQosQueueRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateCenInterRegionTrafficQosQueueOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateCenInterRegionTrafficQosQueueOutcome(CreateCenInterRegionTrafficQosQueueResult(outcome.result()));
+	else
+		return CreateCenInterRegionTrafficQosQueueOutcome(outcome.error());
+}
+
+void CbnClient::createCenInterRegionTrafficQosQueueAsync(const CreateCenInterRegionTrafficQosQueueRequest& request, const CreateCenInterRegionTrafficQosQueueAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createCenInterRegionTrafficQosQueue(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CbnClient::CreateCenInterRegionTrafficQosQueueOutcomeCallable CbnClient::createCenInterRegionTrafficQosQueueCallable(const CreateCenInterRegionTrafficQosQueueRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateCenInterRegionTrafficQosQueueOutcome()>>(
+			[this, request]()
+			{
+			return this->createCenInterRegionTrafficQosQueue(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CbnClient::CreateCenRouteMapOutcome CbnClient::createCenRouteMap(const CreateCenRouteMapRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2355,6 +2391,42 @@ CbnClient::DescribeGrantRulesToCenOutcomeCallable CbnClient::describeGrantRulesT
 	return task->get_future();
 }
 
+CbnClient::DescribeGrantRulesToResourceOutcome CbnClient::describeGrantRulesToResource(const DescribeGrantRulesToResourceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeGrantRulesToResourceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeGrantRulesToResourceOutcome(DescribeGrantRulesToResourceResult(outcome.result()));
+	else
+		return DescribeGrantRulesToResourceOutcome(outcome.error());
+}
+
+void CbnClient::describeGrantRulesToResourceAsync(const DescribeGrantRulesToResourceRequest& request, const DescribeGrantRulesToResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeGrantRulesToResource(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CbnClient::DescribeGrantRulesToResourceOutcomeCallable CbnClient::describeGrantRulesToResourceCallable(const DescribeGrantRulesToResourceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeGrantRulesToResourceOutcome()>>(
+			[this, request]()
+			{
+			return this->describeGrantRulesToResource(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CbnClient::DescribePublishedRouteEntriesOutcome CbnClient::describePublishedRouteEntries(const DescribePublishedRouteEntriesRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -3939,6 +4011,42 @@ CbnClient::RegisterTransitRouterMulticastGroupSourcesOutcomeCallable CbnClient::
 	return task->get_future();
 }
 
+CbnClient::RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcome CbnClient::removeTrafficMatchRuleFromTrafficMarkingPolicy(const RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcome(RemoveTrafficMatchRuleFromTrafficMarkingPolicyResult(outcome.result()));
+	else
+		return RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcome(outcome.error());
+}
+
+void CbnClient::removeTrafficMatchRuleFromTrafficMarkingPolicyAsync(const RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest& request, const RemoveTrafficMatchRuleFromTrafficMarkingPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, removeTrafficMatchRuleFromTrafficMarkingPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CbnClient::RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcomeCallable CbnClient::removeTrafficMatchRuleFromTrafficMarkingPolicyCallable(const RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<RemoveTrafficMatchRuleFromTrafficMarkingPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->removeTrafficMatchRuleFromTrafficMarkingPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CbnClient::RemoveTraficMatchRuleFromTrafficMarkingPolicyOutcome CbnClient::removeTraficMatchRuleFromTrafficMarkingPolicy(const RemoveTraficMatchRuleFromTrafficMarkingPolicyRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

cbn/src/model/CreateCenInterRegionTrafficQosQueueRequest.cc

@@ -0,0 +1,125 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/cbn/model/CreateCenInterRegionTrafficQosQueueRequest.h>
+
+using AlibabaCloud::Cbn::Model::CreateCenInterRegionTrafficQosQueueRequest;
+
+CreateCenInterRegionTrafficQosQueueRequest::CreateCenInterRegionTrafficQosQueueRequest()
+    : RpcServiceRequest("cbn", "2017-09-12", "CreateCenInterRegionTrafficQosQueue") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateCenInterRegionTrafficQosQueueRequest::~CreateCenInterRegionTrafficQosQueueRequest() {}
+
+std::vector<int> CreateCenInterRegionTrafficQosQueueRequest::getDscps() const {
+  return dscps_;
+}
+
+void CreateCenInterRegionTrafficQosQueueRequest::setDscps(const std::vector<int> &dscps) {
+  dscps_ = dscps;
+}
+
+long CreateCenInterRegionTrafficQosQueueRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateCenInterRegionTrafficQosQueueRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateCenInterRegionTrafficQosQueueRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateCenInterRegionTrafficQosQueueRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string CreateCenInterRegionTrafficQosQueueRequest::getQosQueueName() const {
+  return qosQueueName_;
+}
+
+void CreateCenInterRegionTrafficQosQueueRequest::setQosQueueName(const std::string &qosQueueName) {
+  qosQueueName_ = qosQueueName;
+  setParameter(std::string("QosQueueName"), qosQueueName);
+}
+
+std::string CreateCenInterRegionTrafficQosQueueRequest::getRemainBandwidthPercent() const {
+  return remainBandwidthPercent_;
+}
+
+void CreateCenInterRegionTrafficQosQueueRequest::setRemainBandwidthPercent(const std::string &remainBandwidthPercent) {
+  remainBandwidthPercent_ = remainBandwidthPercent;
+  setParameter(std::string("RemainBandwidthPercent"), remainBandwidthPercent);
+}
+
+bool CreateCenInterRegionTrafficQosQueueRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void CreateCenInterRegionTrafficQosQueueRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string CreateCenInterRegionTrafficQosQueueRequest::getTrafficQosPolicyId() const {
+  return trafficQosPolicyId_;
+}
+
+void CreateCenInterRegionTrafficQosQueueRequest::setTrafficQosPolicyId(const std::string &trafficQosPolicyId) {
+  trafficQosPolicyId_ = trafficQosPolicyId;
+  setParameter(std::string("TrafficQosPolicyId"), trafficQosPolicyId);
+}
+
+std::string CreateCenInterRegionTrafficQosQueueRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateCenInterRegionTrafficQosQueueRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateCenInterRegionTrafficQosQueueRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateCenInterRegionTrafficQosQueueRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateCenInterRegionTrafficQosQueueRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateCenInterRegionTrafficQosQueueRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateCenInterRegionTrafficQosQueueRequest::getQosQueueDescription() const {
+  return qosQueueDescription_;
+}
+
+void CreateCenInterRegionTrafficQosQueueRequest::setQosQueueDescription(const std::string &qosQueueDescription) {
+  qosQueueDescription_ = qosQueueDescription;
+  setParameter(std::string("QosQueueDescription"), qosQueueDescription);
+}
+

cbn/src/model/CreateCenInterRegionTrafficQosQueueResult.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/cbn/model/CreateCenInterRegionTrafficQosQueueResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cbn;
+using namespace AlibabaCloud::Cbn::Model;
+
+CreateCenInterRegionTrafficQosQueueResult::CreateCenInterRegionTrafficQosQueueResult() :
+	ServiceResult()
+{}
+
+CreateCenInterRegionTrafficQosQueueResult::CreateCenInterRegionTrafficQosQueueResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateCenInterRegionTrafficQosQueueResult::~CreateCenInterRegionTrafficQosQueueResult()
+{}
+
+void CreateCenInterRegionTrafficQosQueueResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["QosQueueId"].isNull())
+		qosQueueId_ = value["QosQueueId"].asString();
+
+}
+
+std::string CreateCenInterRegionTrafficQosQueueResult::getQosQueueId()const
+{
+	return qosQueueId_;
+}
+

cbn/src/model/DescribeGrantRulesToCenRequest.cc

@@ -61,6 +61,15 @@ void DescribeGrantRulesToCenRequest::setRegionId(const std::string &regionId) {
   setParameter(std::string("RegionId"), regionId);
 }
 
+std::string DescribeGrantRulesToCenRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void DescribeGrantRulesToCenRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
 std::string DescribeGrantRulesToCenRequest::getResourceOwnerAccount() const {
   return resourceOwnerAccount_;
 }
@@ -88,3 +97,12 @@ void DescribeGrantRulesToCenRequest::setOwnerId(long ownerId) {
   setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
+long DescribeGrantRulesToCenRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeGrantRulesToCenRequest::setMaxResults(long maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+

cbn/src/model/DescribeGrantRulesToCenResult.cc

@@ -55,11 +55,34 @@ void DescribeGrantRulesToCenResult::parse(const std::string &payload)
 			grantRulesObject.cenId = valueGrantRulesGrantRule["CenId"].asString();
 		if(!valueGrantRulesGrantRule["OrderType"].isNull())
 			grantRulesObject.orderType = valueGrantRulesGrantRule["OrderType"].asString();
+		if(!valueGrantRulesGrantRule["CenOwnerId"].isNull())
+			grantRulesObject.cenOwnerId = std::stol(valueGrantRulesGrantRule["CenOwnerId"].asString());
 		grantRules_.push_back(grantRulesObject);
 	}
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stol(value["TotalCount"].asString());
+	if(!value["MaxResults"].isNull())
+		maxResults_ = std::stol(value["MaxResults"].asString());
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
 
 }
 
+long DescribeGrantRulesToCenResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string DescribeGrantRulesToCenResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+long DescribeGrantRulesToCenResult::getMaxResults()const
+{
+	return maxResults_;
+}
+
 std::vector<DescribeGrantRulesToCenResult::GrantRule> DescribeGrantRulesToCenResult::getGrantRules()const
 {
 	return grantRules_;

cbn/src/model/DescribeGrantRulesToResourceRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/cbn/model/DescribeGrantRulesToResourceRequest.h>
+
+using AlibabaCloud::Cbn::Model::DescribeGrantRulesToResourceRequest;
+
+DescribeGrantRulesToResourceRequest::DescribeGrantRulesToResourceRequest()
+    : RpcServiceRequest("cbn", "2017-09-12", "DescribeGrantRulesToResource") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeGrantRulesToResourceRequest::~DescribeGrantRulesToResourceRequest() {}
+
+long DescribeGrantRulesToResourceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeGrantRulesToResourceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeGrantRulesToResourceRequest::getProductType() const {
+  return productType_;
+}
+
+void DescribeGrantRulesToResourceRequest::setProductType(const std::string &productType) {
+  productType_ = productType;
+  setParameter(std::string("ProductType"), productType);
+}
+
+std::string DescribeGrantRulesToResourceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeGrantRulesToResourceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeGrantRulesToResourceRequest::getNextToken() const {
+  return nextToken_;
+}
+
+void DescribeGrantRulesToResourceRequest::setNextToken(const std::string &nextToken) {
+  nextToken_ = nextToken;
+  setParameter(std::string("NextToken"), nextToken);
+}
+
+std::string DescribeGrantRulesToResourceRequest::getResourceId() const {
+  return resourceId_;
+}
+
+void DescribeGrantRulesToResourceRequest::setResourceId(const std::string &resourceId) {
+  resourceId_ = resourceId;
+  setParameter(std::string("ResourceId"), resourceId);
+}
+
+std::string DescribeGrantRulesToResourceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeGrantRulesToResourceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeGrantRulesToResourceRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeGrantRulesToResourceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DescribeGrantRulesToResourceRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeGrantRulesToResourceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+int DescribeGrantRulesToResourceRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeGrantRulesToResourceRequest::setMaxResults(int maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+

cbn/src/model/DescribeGrantRulesToResourceResult.cc

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/cbn/model/DescribeGrantRulesToResourceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cbn;
+using namespace AlibabaCloud::Cbn::Model;
+
+DescribeGrantRulesToResourceResult::DescribeGrantRulesToResourceResult() :
+	ServiceResult()
+{}
+
+DescribeGrantRulesToResourceResult::DescribeGrantRulesToResourceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeGrantRulesToResourceResult::~DescribeGrantRulesToResourceResult()
+{}
+
+void DescribeGrantRulesToResourceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allGrantRulesNode = value["GrantRules"]["GrantRule"];
+	for (auto valueGrantRulesGrantRule : allGrantRulesNode)
+	{
+		GrantRule grantRulesObject;
+		if(!valueGrantRulesGrantRule["CenOwnerId"].isNull())
+			grantRulesObject.cenOwnerId = std::stol(valueGrantRulesGrantRule["CenOwnerId"].asString());
+		if(!valueGrantRulesGrantRule["OrderType"].isNull())
+			grantRulesObject.orderType = valueGrantRulesGrantRule["OrderType"].asString();
+		if(!valueGrantRulesGrantRule["CenId"].isNull())
+			grantRulesObject.cenId = valueGrantRulesGrantRule["CenId"].asString();
+		grantRules_.push_back(grantRulesObject);
+	}
+	if(!value["NextToken"].isNull())
+		nextToken_ = value["NextToken"].asString();
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+	if(!value["MaxResults"].isNull())
+		maxResults_ = std::stoi(value["MaxResults"].asString());
+
+}
+
+int DescribeGrantRulesToResourceResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::string DescribeGrantRulesToResourceResult::getNextToken()const
+{
+	return nextToken_;
+}
+
+int DescribeGrantRulesToResourceResult::getMaxResults()const
+{
+	return maxResults_;
+}
+
+std::vector<DescribeGrantRulesToResourceResult::GrantRule> DescribeGrantRulesToResourceResult::getGrantRules()const
+{
+	return grantRules_;
+}
+

cbn/src/model/ListTransitRouterMulticastDomainAssociationsRequest.cc

@@ -78,15 +78,6 @@ void ListTransitRouterMulticastDomainAssociationsRequest::setResourceId(const st
   setParameter(std::string("ResourceId"), resourceId);
 }
 
-bool ListTransitRouterMulticastDomainAssociationsRequest::getDryRun() const {
-  return dryRun_;
-}
-
-void ListTransitRouterMulticastDomainAssociationsRequest::setDryRun(bool dryRun) {
-  dryRun_ = dryRun;
-  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
-}
-
 std::string ListTransitRouterMulticastDomainAssociationsRequest::getResourceOwnerAccount() const {
   return resourceOwnerAccount_;
 }

cbn/src/model/ListTransitRouterMulticastDomainsRequest.cc

@@ -79,15 +79,6 @@ void ListTransitRouterMulticastDomainsRequest::setNextToken(const std::string &n
   setParameter(std::string("NextToken"), nextToken);
 }
 
-bool ListTransitRouterMulticastDomainsRequest::getDryRun() const {
-  return dryRun_;
-}
-
-void ListTransitRouterMulticastDomainsRequest::setDryRun(bool dryRun) {
-  dryRun_ = dryRun;
-  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
-}
-
 std::string ListTransitRouterMulticastDomainsRequest::getResourceOwnerAccount() const {
   return resourceOwnerAccount_;
 }

cbn/src/model/ListTransitRouterPrefixListAssociationResult.cc

@@ -57,6 +57,8 @@ void ListTransitRouterPrefixListAssociationResult::parse(const std::string &payl
 			prefixListsObject.nextHopType = valuePrefixListsPrefixList["NextHopType"].asString();
 		if(!valuePrefixListsPrefixList["TransitRouterTableId"].isNull())
 			prefixListsObject.transitRouterTableId = valuePrefixListsPrefixList["TransitRouterTableId"].asString();
+		if(!valuePrefixListsPrefixList["TransitRouterId"].isNull())
+			prefixListsObject.transitRouterId = valuePrefixListsPrefixList["TransitRouterId"].asString();
 		prefixLists_.push_back(prefixListsObject);
 	}
 	if(!value["TotalCount"].isNull())

cbn/src/model/RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest.cc

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/cbn/model/RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest.h>
+
+using AlibabaCloud::Cbn::Model::RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest;
+
+RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest()
+    : RpcServiceRequest("cbn", "2017-09-12", "RemoveTrafficMatchRuleFromTrafficMarkingPolicy") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::~RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest() {}
+
+long RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::getTrafficMarkingPolicyId() const {
+  return trafficMarkingPolicyId_;
+}
+
+void RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::setTrafficMarkingPolicyId(const std::string &trafficMarkingPolicyId) {
+  trafficMarkingPolicyId_ = trafficMarkingPolicyId;
+  setParameter(std::string("TrafficMarkingPolicyId"), trafficMarkingPolicyId);
+}
+
+bool RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+std::vector<std::string> RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::getTrafficMarkRuleIds() const {
+  return trafficMarkRuleIds_;
+}
+
+void RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::setTrafficMarkRuleIds(const std::vector<std::string> &trafficMarkRuleIds) {
+  trafficMarkRuleIds_ = trafficMarkRuleIds;
+}
+
+long RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void RemoveTrafficMatchRuleFromTrafficMarkingPolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+

cbn/src/model/RemoveTrafficMatchRuleFromTrafficMarkingPolicyResult.cc

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