Supported API for GTM.

alidns/src/model/AddDnsGtmAccessStrategyRequest.cc

@@ -0,0 +1,237 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/AddDnsGtmAccessStrategyRequest.h>
+
+using AlibabaCloud::Alidns::Model::AddDnsGtmAccessStrategyRequest;
+
+AddDnsGtmAccessStrategyRequest::AddDnsGtmAccessStrategyRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "AddDnsGtmAccessStrategy")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddDnsGtmAccessStrategyRequest::~AddDnsGtmAccessStrategyRequest()
+{}
+
+std::string AddDnsGtmAccessStrategyRequest::getDefaultLbaStrategy()const
+{
+	return defaultLbaStrategy_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setDefaultLbaStrategy(const std::string& defaultLbaStrategy)
+{
+	defaultLbaStrategy_ = defaultLbaStrategy;
+	setParameter("DefaultLbaStrategy", defaultLbaStrategy);
+}
+
+std::string AddDnsGtmAccessStrategyRequest::getFailoverAddrPoolType()const
+{
+	return failoverAddrPoolType_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setFailoverAddrPoolType(const std::string& failoverAddrPoolType)
+{
+	failoverAddrPoolType_ = failoverAddrPoolType;
+	setParameter("FailoverAddrPoolType", failoverAddrPoolType);
+}
+
+std::string AddDnsGtmAccessStrategyRequest::getDefaultAddrPoolType()const
+{
+	return defaultAddrPoolType_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setDefaultAddrPoolType(const std::string& defaultAddrPoolType)
+{
+	defaultAddrPoolType_ = defaultAddrPoolType;
+	setParameter("DefaultAddrPoolType", defaultAddrPoolType);
+}
+
+int AddDnsGtmAccessStrategyRequest::getFailoverMaxReturnAddrNum()const
+{
+	return failoverMaxReturnAddrNum_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setFailoverMaxReturnAddrNum(int failoverMaxReturnAddrNum)
+{
+	failoverMaxReturnAddrNum_ = failoverMaxReturnAddrNum;
+	setParameter("FailoverMaxReturnAddrNum", std::to_string(failoverMaxReturnAddrNum));
+}
+
+std::string AddDnsGtmAccessStrategyRequest::getFailoverLbaStrategy()const
+{
+	return failoverLbaStrategy_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setFailoverLbaStrategy(const std::string& failoverLbaStrategy)
+{
+	failoverLbaStrategy_ = failoverLbaStrategy;
+	setParameter("FailoverLbaStrategy", failoverLbaStrategy);
+}
+
+std::vector<AddDnsGtmAccessStrategyRequest::DefaultAddrPool> AddDnsGtmAccessStrategyRequest::getDefaultAddrPool()const
+{
+	return defaultAddrPool_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setDefaultAddrPool(const std::vector<DefaultAddrPool>& defaultAddrPool)
+{
+	defaultAddrPool_ = defaultAddrPool;
+	for(int dep1 = 0; dep1!= defaultAddrPool.size(); dep1++) {
+		auto defaultAddrPoolObj = defaultAddrPool.at(dep1);
+		std::string defaultAddrPoolObjStr = "DefaultAddrPool." + std::to_string(dep1 + 1);
+		setParameter(defaultAddrPoolObjStr + ".Id", defaultAddrPoolObj.id);
+		setParameter(defaultAddrPoolObjStr + ".LbaWeight", std::to_string(defaultAddrPoolObj.lbaWeight));
+	}
+}
+
+int AddDnsGtmAccessStrategyRequest::getFailoverMinAvailableAddrNum()const
+{
+	return failoverMinAvailableAddrNum_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setFailoverMinAvailableAddrNum(int failoverMinAvailableAddrNum)
+{
+	failoverMinAvailableAddrNum_ = failoverMinAvailableAddrNum;
+	setParameter("FailoverMinAvailableAddrNum", std::to_string(failoverMinAvailableAddrNum));
+}
+
+int AddDnsGtmAccessStrategyRequest::getDefaultMaxReturnAddrNum()const
+{
+	return defaultMaxReturnAddrNum_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setDefaultMaxReturnAddrNum(int defaultMaxReturnAddrNum)
+{
+	defaultMaxReturnAddrNum_ = defaultMaxReturnAddrNum;
+	setParameter("DefaultMaxReturnAddrNum", std::to_string(defaultMaxReturnAddrNum));
+}
+
+int AddDnsGtmAccessStrategyRequest::getDefaultMinAvailableAddrNum()const
+{
+	return defaultMinAvailableAddrNum_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setDefaultMinAvailableAddrNum(int defaultMinAvailableAddrNum)
+{
+	defaultMinAvailableAddrNum_ = defaultMinAvailableAddrNum;
+	setParameter("DefaultMinAvailableAddrNum", std::to_string(defaultMinAvailableAddrNum));
+}
+
+std::string AddDnsGtmAccessStrategyRequest::getStrategyMode()const
+{
+	return strategyMode_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setStrategyMode(const std::string& strategyMode)
+{
+	strategyMode_ = strategyMode;
+	setParameter("StrategyMode", strategyMode);
+}
+
+std::string AddDnsGtmAccessStrategyRequest::getLang()const
+{
+	return lang_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::string AddDnsGtmAccessStrategyRequest::getLines()const
+{
+	return lines_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setLines(const std::string& lines)
+{
+	lines_ = lines;
+	setParameter("Lines", lines);
+}
+
+std::string AddDnsGtmAccessStrategyRequest::getStrategyName()const
+{
+	return strategyName_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setStrategyName(const std::string& strategyName)
+{
+	strategyName_ = strategyName;
+	setParameter("StrategyName", strategyName);
+}
+
+std::string AddDnsGtmAccessStrategyRequest::getDefaultLatencyOptimization()const
+{
+	return defaultLatencyOptimization_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setDefaultLatencyOptimization(const std::string& defaultLatencyOptimization)
+{
+	defaultLatencyOptimization_ = defaultLatencyOptimization;
+	setParameter("DefaultLatencyOptimization", defaultLatencyOptimization);
+}
+
+std::string AddDnsGtmAccessStrategyRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string AddDnsGtmAccessStrategyRequest::getFailoverLatencyOptimization()const
+{
+	return failoverLatencyOptimization_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setFailoverLatencyOptimization(const std::string& failoverLatencyOptimization)
+{
+	failoverLatencyOptimization_ = failoverLatencyOptimization;
+	setParameter("FailoverLatencyOptimization", failoverLatencyOptimization);
+}
+
+std::string AddDnsGtmAccessStrategyRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::vector<AddDnsGtmAccessStrategyRequest::FailoverAddrPool> AddDnsGtmAccessStrategyRequest::getFailoverAddrPool()const
+{
+	return failoverAddrPool_;
+}
+
+void AddDnsGtmAccessStrategyRequest::setFailoverAddrPool(const std::vector<FailoverAddrPool>& failoverAddrPool)
+{
+	failoverAddrPool_ = failoverAddrPool;
+	for(int dep1 = 0; dep1!= failoverAddrPool.size(); dep1++) {
+		auto failoverAddrPoolObj = failoverAddrPool.at(dep1);
+		std::string failoverAddrPoolObjStr = "FailoverAddrPool." + std::to_string(dep1 + 1);
+		setParameter(failoverAddrPoolObjStr + ".Id", failoverAddrPoolObj.id);
+		setParameter(failoverAddrPoolObjStr + ".LbaWeight", std::to_string(failoverAddrPoolObj.lbaWeight));
+	}
+}
+

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

alidns/src/model/AddDnsGtmAddressPoolRequest.cc

@@ -0,0 +1,196 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/AddDnsGtmAddressPoolRequest.h>
+
+using AlibabaCloud::Alidns::Model::AddDnsGtmAddressPoolRequest;
+
+AddDnsGtmAddressPoolRequest::AddDnsGtmAddressPoolRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "AddDnsGtmAddressPool")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddDnsGtmAddressPoolRequest::~AddDnsGtmAddressPoolRequest()
+{}
+
+std::string AddDnsGtmAddressPoolRequest::getMonitorExtendInfo()const
+{
+	return monitorExtendInfo_;
+}
+
+void AddDnsGtmAddressPoolRequest::setMonitorExtendInfo(const std::string& monitorExtendInfo)
+{
+	monitorExtendInfo_ = monitorExtendInfo;
+	setParameter("MonitorExtendInfo", monitorExtendInfo);
+}
+
+std::string AddDnsGtmAddressPoolRequest::getLbaStrategy()const
+{
+	return lbaStrategy_;
+}
+
+void AddDnsGtmAddressPoolRequest::setLbaStrategy(const std::string& lbaStrategy)
+{
+	lbaStrategy_ = lbaStrategy;
+	setParameter("LbaStrategy", lbaStrategy);
+}
+
+std::string AddDnsGtmAddressPoolRequest::getType()const
+{
+	return type_;
+}
+
+void AddDnsGtmAddressPoolRequest::setType(const std::string& type)
+{
+	type_ = type;
+	setParameter("Type", type);
+}
+
+int AddDnsGtmAddressPoolRequest::getTimeout()const
+{
+	return timeout_;
+}
+
+void AddDnsGtmAddressPoolRequest::setTimeout(int timeout)
+{
+	timeout_ = timeout;
+	setParameter("Timeout", std::to_string(timeout));
+}
+
+int AddDnsGtmAddressPoolRequest::getEvaluationCount()const
+{
+	return evaluationCount_;
+}
+
+void AddDnsGtmAddressPoolRequest::setEvaluationCount(int evaluationCount)
+{
+	evaluationCount_ = evaluationCount;
+	setParameter("EvaluationCount", std::to_string(evaluationCount));
+}
+
+std::string AddDnsGtmAddressPoolRequest::getLang()const
+{
+	return lang_;
+}
+
+void AddDnsGtmAddressPoolRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::vector<AddDnsGtmAddressPoolRequest::Addr> AddDnsGtmAddressPoolRequest::getAddr()const
+{
+	return addr_;
+}
+
+void AddDnsGtmAddressPoolRequest::setAddr(const std::vector<Addr>& addr)
+{
+	addr_ = addr;
+	for(int dep1 = 0; dep1!= addr.size(); dep1++) {
+		auto addrObj = addr.at(dep1);
+		std::string addrObjStr = "Addr." + std::to_string(dep1 + 1);
+		setParameter(addrObjStr + ".Mode", addrObj.mode);
+		setParameter(addrObjStr + ".AttributeInfo", addrObj.attributeInfo);
+		setParameter(addrObjStr + ".Remark", addrObj.remark);
+		setParameter(addrObjStr + ".Addr", addrObj.addr);
+		setParameter(addrObjStr + ".LbaWeight", std::to_string(addrObj.lbaWeight));
+	}
+}
+
+std::string AddDnsGtmAddressPoolRequest::getMonitorStatus()const
+{
+	return monitorStatus_;
+}
+
+void AddDnsGtmAddressPoolRequest::setMonitorStatus(const std::string& monitorStatus)
+{
+	monitorStatus_ = monitorStatus;
+	setParameter("MonitorStatus", monitorStatus);
+}
+
+std::string AddDnsGtmAddressPoolRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void AddDnsGtmAddressPoolRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string AddDnsGtmAddressPoolRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void AddDnsGtmAddressPoolRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string AddDnsGtmAddressPoolRequest::getName()const
+{
+	return name_;
+}
+
+void AddDnsGtmAddressPoolRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string AddDnsGtmAddressPoolRequest::getProtocolType()const
+{
+	return protocolType_;
+}
+
+void AddDnsGtmAddressPoolRequest::setProtocolType(const std::string& protocolType)
+{
+	protocolType_ = protocolType;
+	setParameter("ProtocolType", protocolType);
+}
+
+int AddDnsGtmAddressPoolRequest::getInterval()const
+{
+	return interval_;
+}
+
+void AddDnsGtmAddressPoolRequest::setInterval(int interval)
+{
+	interval_ = interval;
+	setParameter("Interval", std::to_string(interval));
+}
+
+std::vector<AddDnsGtmAddressPoolRequest::IspCityNode> AddDnsGtmAddressPoolRequest::getIspCityNode()const
+{
+	return ispCityNode_;
+}
+
+void AddDnsGtmAddressPoolRequest::setIspCityNode(const std::vector<IspCityNode>& ispCityNode)
+{
+	ispCityNode_ = ispCityNode;
+	for(int dep1 = 0; dep1!= ispCityNode.size(); dep1++) {
+		auto ispCityNodeObj = ispCityNode.at(dep1);
+		std::string ispCityNodeObjStr = "IspCityNode." + std::to_string(dep1 + 1);
+		setParameter(ispCityNodeObjStr + ".CityCode", ispCityNodeObj.cityCode);
+		setParameter(ispCityNodeObjStr + ".IspCode", ispCityNodeObj.ispCode);
+	}
+}
+

alidns/src/model/AddDnsGtmAddressPoolResult.cc

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

alidns/src/model/AddDnsGtmMonitorRequest.cc

@@ -0,0 +1,133 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/AddDnsGtmMonitorRequest.h>
+
+using AlibabaCloud::Alidns::Model::AddDnsGtmMonitorRequest;
+
+AddDnsGtmMonitorRequest::AddDnsGtmMonitorRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "AddDnsGtmMonitor")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+AddDnsGtmMonitorRequest::~AddDnsGtmMonitorRequest()
+{}
+
+std::string AddDnsGtmMonitorRequest::getMonitorExtendInfo()const
+{
+	return monitorExtendInfo_;
+}
+
+void AddDnsGtmMonitorRequest::setMonitorExtendInfo(const std::string& monitorExtendInfo)
+{
+	monitorExtendInfo_ = monitorExtendInfo;
+	setParameter("MonitorExtendInfo", monitorExtendInfo);
+}
+
+int AddDnsGtmMonitorRequest::getTimeout()const
+{
+	return timeout_;
+}
+
+void AddDnsGtmMonitorRequest::setTimeout(int timeout)
+{
+	timeout_ = timeout;
+	setParameter("Timeout", std::to_string(timeout));
+}
+
+std::string AddDnsGtmMonitorRequest::getAddrPoolId()const
+{
+	return addrPoolId_;
+}
+
+void AddDnsGtmMonitorRequest::setAddrPoolId(const std::string& addrPoolId)
+{
+	addrPoolId_ = addrPoolId;
+	setParameter("AddrPoolId", addrPoolId);
+}
+
+std::string AddDnsGtmMonitorRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void AddDnsGtmMonitorRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+int AddDnsGtmMonitorRequest::getEvaluationCount()const
+{
+	return evaluationCount_;
+}
+
+void AddDnsGtmMonitorRequest::setEvaluationCount(int evaluationCount)
+{
+	evaluationCount_ = evaluationCount;
+	setParameter("EvaluationCount", std::to_string(evaluationCount));
+}
+
+std::string AddDnsGtmMonitorRequest::getProtocolType()const
+{
+	return protocolType_;
+}
+
+void AddDnsGtmMonitorRequest::setProtocolType(const std::string& protocolType)
+{
+	protocolType_ = protocolType;
+	setParameter("ProtocolType", protocolType);
+}
+
+int AddDnsGtmMonitorRequest::getInterval()const
+{
+	return interval_;
+}
+
+void AddDnsGtmMonitorRequest::setInterval(int interval)
+{
+	interval_ = interval;
+	setParameter("Interval", std::to_string(interval));
+}
+
+std::string AddDnsGtmMonitorRequest::getLang()const
+{
+	return lang_;
+}
+
+void AddDnsGtmMonitorRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::vector<AddDnsGtmMonitorRequest::IspCityNode> AddDnsGtmMonitorRequest::getIspCityNode()const
+{
+	return ispCityNode_;
+}
+
+void AddDnsGtmMonitorRequest::setIspCityNode(const std::vector<IspCityNode>& ispCityNode)
+{
+	ispCityNode_ = ispCityNode;
+	for(int dep1 = 0; dep1!= ispCityNode.size(); dep1++) {
+		auto ispCityNodeObj = ispCityNode.at(dep1);
+		std::string ispCityNodeObjStr = "IspCityNode." + std::to_string(dep1 + 1);
+		setParameter(ispCityNodeObjStr + ".CityCode", ispCityNodeObj.cityCode);
+		setParameter(ispCityNodeObjStr + ".IspCode", ispCityNodeObj.ispCode);
+	}
+}
+

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

alidns/src/model/DeleteDnsGtmAccessStrategyRequest.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/alidns/model/DeleteDnsGtmAccessStrategyRequest.h>
+
+using AlibabaCloud::Alidns::Model::DeleteDnsGtmAccessStrategyRequest;
+
+DeleteDnsGtmAccessStrategyRequest::DeleteDnsGtmAccessStrategyRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DeleteDnsGtmAccessStrategy")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDnsGtmAccessStrategyRequest::~DeleteDnsGtmAccessStrategyRequest()
+{}
+
+std::string DeleteDnsGtmAccessStrategyRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DeleteDnsGtmAccessStrategyRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DeleteDnsGtmAccessStrategyRequest::getStrategyId()const
+{
+	return strategyId_;
+}
+
+void DeleteDnsGtmAccessStrategyRequest::setStrategyId(const std::string& strategyId)
+{
+	strategyId_ = strategyId;
+	setParameter("StrategyId", strategyId);
+}
+
+std::string DeleteDnsGtmAccessStrategyRequest::getLang()const
+{
+	return lang_;
+}
+
+void DeleteDnsGtmAccessStrategyRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

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

alidns/src/model/DeleteDnsGtmAddressPoolRequest.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/alidns/model/DeleteDnsGtmAddressPoolRequest.h>
+
+using AlibabaCloud::Alidns::Model::DeleteDnsGtmAddressPoolRequest;
+
+DeleteDnsGtmAddressPoolRequest::DeleteDnsGtmAddressPoolRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DeleteDnsGtmAddressPool")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDnsGtmAddressPoolRequest::~DeleteDnsGtmAddressPoolRequest()
+{}
+
+std::string DeleteDnsGtmAddressPoolRequest::getAddrPoolId()const
+{
+	return addrPoolId_;
+}
+
+void DeleteDnsGtmAddressPoolRequest::setAddrPoolId(const std::string& addrPoolId)
+{
+	addrPoolId_ = addrPoolId;
+	setParameter("AddrPoolId", addrPoolId);
+}
+
+std::string DeleteDnsGtmAddressPoolRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DeleteDnsGtmAddressPoolRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DeleteDnsGtmAddressPoolRequest::getLang()const
+{
+	return lang_;
+}
+
+void DeleteDnsGtmAddressPoolRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

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

alidns/src/model/DescribeCustomLinesResult.cc

@@ -55,16 +55,16 @@ void DescribeCustomLinesResult::parse(const std::string &payload)
 			customLinesObject.ipSegments = valueCustomLinesCustomLine["IpSegments"].asString();
 		if(!valueCustomLinesCustomLine["Code"].isNull())
 			customLinesObject.code = valueCustomLinesCustomLine["Code"].asString();
-		auto allIpSegmentListNode = allCustomLinesNode["IpSegmentList"]["IpSegment"];
-		for (auto allCustomLinesNodeIpSegmentListIpSegment : allIpSegmentListNode)
+		auto allIpSegmentListNode = valueCustomLinesCustomLine["IpSegmentList"]["IpSegment"];
+		for (auto valueCustomLinesCustomLineIpSegmentListIpSegment : allIpSegmentListNode)
 		{
 			CustomLine::IpSegment ipSegmentListObject;
-			if(!allCustomLinesNodeIpSegmentListIpSegment["Name"].isNull())
-				ipSegmentListObject.name = allCustomLinesNodeIpSegmentListIpSegment["Name"].asString();
-			if(!allCustomLinesNodeIpSegmentListIpSegment["StartIp"].isNull())
-				ipSegmentListObject.startIp = allCustomLinesNodeIpSegmentListIpSegment["StartIp"].asString();
-			if(!allCustomLinesNodeIpSegmentListIpSegment["EndIp"].isNull())
-				ipSegmentListObject.endIp = allCustomLinesNodeIpSegmentListIpSegment["EndIp"].asString();
+			if(!valueCustomLinesCustomLineIpSegmentListIpSegment["Name"].isNull())
+				ipSegmentListObject.name = valueCustomLinesCustomLineIpSegmentListIpSegment["Name"].asString();
+			if(!valueCustomLinesCustomLineIpSegmentListIpSegment["StartIp"].isNull())
+				ipSegmentListObject.startIp = valueCustomLinesCustomLineIpSegmentListIpSegment["StartIp"].asString();
+			if(!valueCustomLinesCustomLineIpSegmentListIpSegment["EndIp"].isNull())
+				ipSegmentListObject.endIp = valueCustomLinesCustomLineIpSegmentListIpSegment["EndIp"].asString();
 			customLinesObject.ipSegmentList.push_back(ipSegmentListObject);
 		}
 		customLines_.push_back(customLinesObject);

alidns/src/model/DescribeDnsGtmAccessStrategiesRequest.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/alidns/model/DescribeDnsGtmAccessStrategiesRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmAccessStrategiesRequest;
+
+DescribeDnsGtmAccessStrategiesRequest::DescribeDnsGtmAccessStrategiesRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmAccessStrategies")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmAccessStrategiesRequest::~DescribeDnsGtmAccessStrategiesRequest()
+{}
+
+int DescribeDnsGtmAccessStrategiesRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeDnsGtmAccessStrategiesRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeDnsGtmAccessStrategiesRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeDnsGtmAccessStrategiesRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string DescribeDnsGtmAccessStrategiesRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmAccessStrategiesRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+int DescribeDnsGtmAccessStrategiesRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeDnsGtmAccessStrategiesRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeDnsGtmAccessStrategiesRequest::getStrategyMode()const
+{
+	return strategyMode_;
+}
+
+void DescribeDnsGtmAccessStrategiesRequest::setStrategyMode(const std::string& strategyMode)
+{
+	strategyMode_ = strategyMode;
+	setParameter("StrategyMode", strategyMode);
+}
+
+std::string DescribeDnsGtmAccessStrategiesRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmAccessStrategiesRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/DescribeDnsGtmAccessStrategiesResult.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/alidns/model/DescribeDnsGtmAccessStrategiesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmAccessStrategiesResult::DescribeDnsGtmAccessStrategiesResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmAccessStrategiesResult::DescribeDnsGtmAccessStrategiesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmAccessStrategiesResult::~DescribeDnsGtmAccessStrategiesResult()
+{}
+
+void DescribeDnsGtmAccessStrategiesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allStrategiesNode = value["Strategies"]["Strategy"];
+	for (auto valueStrategiesStrategy : allStrategiesNode)
+	{
+		Strategy strategiesObject;
+		if(!valueStrategiesStrategy["StrategyId"].isNull())
+			strategiesObject.strategyId = valueStrategiesStrategy["StrategyId"].asString();
+		if(!valueStrategiesStrategy["StrategyName"].isNull())
+			strategiesObject.strategyName = valueStrategiesStrategy["StrategyName"].asString();
+		if(!valueStrategiesStrategy["CreateTime"].isNull())
+			strategiesObject.createTime = valueStrategiesStrategy["CreateTime"].asString();
+		if(!valueStrategiesStrategy["CreateTimestamp"].isNull())
+			strategiesObject.createTimestamp = std::stol(valueStrategiesStrategy["CreateTimestamp"].asString());
+		if(!valueStrategiesStrategy["EffectiveAddrPoolGroupType"].isNull())
+			strategiesObject.effectiveAddrPoolGroupType = valueStrategiesStrategy["EffectiveAddrPoolGroupType"].asString();
+		if(!valueStrategiesStrategy["EffectiveAddrPoolType"].isNull())
+			strategiesObject.effectiveAddrPoolType = valueStrategiesStrategy["EffectiveAddrPoolType"].asString();
+		if(!valueStrategiesStrategy["EffectiveLbaStrategy"].isNull())
+			strategiesObject.effectiveLbaStrategy = valueStrategiesStrategy["EffectiveLbaStrategy"].asString();
+		auto allLinesNode = valueStrategiesStrategy["Lines"]["Line"];
+		for (auto valueStrategiesStrategyLinesLine : allLinesNode)
+		{
+			Strategy::Line linesObject;
+			if(!valueStrategiesStrategyLinesLine["LineCode"].isNull())
+				linesObject.lineCode = valueStrategiesStrategyLinesLine["LineCode"].asString();
+			if(!valueStrategiesStrategyLinesLine["LineName"].isNull())
+				linesObject.lineName = valueStrategiesStrategyLinesLine["LineName"].asString();
+			if(!valueStrategiesStrategyLinesLine["GroupCode"].isNull())
+				linesObject.groupCode = valueStrategiesStrategyLinesLine["GroupCode"].asString();
+			if(!valueStrategiesStrategyLinesLine["GroupName"].isNull())
+				linesObject.groupName = valueStrategiesStrategyLinesLine["GroupName"].asString();
+			strategiesObject.lines.push_back(linesObject);
+		}
+		auto allEffectiveAddrPoolsNode = valueStrategiesStrategy["EffectiveAddrPools"]["EffectiveAddrPool"];
+		for (auto valueStrategiesStrategyEffectiveAddrPoolsEffectiveAddrPool : allEffectiveAddrPoolsNode)
+		{
+			Strategy::EffectiveAddrPool effectiveAddrPoolsObject;
+			if(!valueStrategiesStrategyEffectiveAddrPoolsEffectiveAddrPool["Id"].isNull())
+				effectiveAddrPoolsObject.id = valueStrategiesStrategyEffectiveAddrPoolsEffectiveAddrPool["Id"].asString();
+			if(!valueStrategiesStrategyEffectiveAddrPoolsEffectiveAddrPool["Name"].isNull())
+				effectiveAddrPoolsObject.name = valueStrategiesStrategyEffectiveAddrPoolsEffectiveAddrPool["Name"].asString();
+			if(!valueStrategiesStrategyEffectiveAddrPoolsEffectiveAddrPool["AddrCount"].isNull())
+				effectiveAddrPoolsObject.addrCount = std::stoi(valueStrategiesStrategyEffectiveAddrPoolsEffectiveAddrPool["AddrCount"].asString());
+			if(!valueStrategiesStrategyEffectiveAddrPoolsEffectiveAddrPool["LbaWeight"].isNull())
+				effectiveAddrPoolsObject.lbaWeight = std::stoi(valueStrategiesStrategyEffectiveAddrPoolsEffectiveAddrPool["LbaWeight"].asString());
+			strategiesObject.effectiveAddrPools.push_back(effectiveAddrPoolsObject);
+		}
+		strategies_.push_back(strategiesObject);
+	}
+	if(!value["TotalItems"].isNull())
+		totalItems_ = std::stoi(value["TotalItems"].asString());
+	if(!value["TotalPages"].isNull())
+		totalPages_ = std::stoi(value["TotalPages"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+int DescribeDnsGtmAccessStrategiesResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeDnsGtmAccessStrategiesResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeDnsGtmAccessStrategiesResult::Strategy> DescribeDnsGtmAccessStrategiesResult::getStrategies()const
+{
+	return strategies_;
+}
+
+int DescribeDnsGtmAccessStrategiesResult::getTotalPages()const
+{
+	return totalPages_;
+}
+
+int DescribeDnsGtmAccessStrategiesResult::getTotalItems()const
+{
+	return totalItems_;
+}
+

alidns/src/model/DescribeDnsGtmAccessStrategyAvailableConfigRequest.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/alidns/model/DescribeDnsGtmAccessStrategyAvailableConfigRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmAccessStrategyAvailableConfigRequest;
+
+DescribeDnsGtmAccessStrategyAvailableConfigRequest::DescribeDnsGtmAccessStrategyAvailableConfigRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmAccessStrategyAvailableConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmAccessStrategyAvailableConfigRequest::~DescribeDnsGtmAccessStrategyAvailableConfigRequest()
+{}
+
+std::string DescribeDnsGtmAccessStrategyAvailableConfigRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeDnsGtmAccessStrategyAvailableConfigRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string DescribeDnsGtmAccessStrategyAvailableConfigRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmAccessStrategyAvailableConfigRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DescribeDnsGtmAccessStrategyAvailableConfigRequest::getStrategyMode()const
+{
+	return strategyMode_;
+}
+
+void DescribeDnsGtmAccessStrategyAvailableConfigRequest::setStrategyMode(const std::string& strategyMode)
+{
+	strategyMode_ = strategyMode;
+	setParameter("StrategyMode", strategyMode);
+}
+
+std::string DescribeDnsGtmAccessStrategyAvailableConfigRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmAccessStrategyAvailableConfigRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/DescribeDnsGtmAccessStrategyAvailableConfigResult.cc

@@ -0,0 +1,123 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/DescribeDnsGtmAccessStrategyAvailableConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmAccessStrategyAvailableConfigResult::DescribeDnsGtmAccessStrategyAvailableConfigResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmAccessStrategyAvailableConfigResult::DescribeDnsGtmAccessStrategyAvailableConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmAccessStrategyAvailableConfigResult::~DescribeDnsGtmAccessStrategyAvailableConfigResult()
+{}
+
+void DescribeDnsGtmAccessStrategyAvailableConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allIpv4AddrPoolsNode = value["Ipv4AddrPools"]["Ipv4AddrPool"];
+	for (auto valueIpv4AddrPoolsIpv4AddrPool : allIpv4AddrPoolsNode)
+	{
+		Ipv4AddrPool ipv4AddrPoolsObject;
+		if(!valueIpv4AddrPoolsIpv4AddrPool["Id"].isNull())
+			ipv4AddrPoolsObject.id = valueIpv4AddrPoolsIpv4AddrPool["Id"].asString();
+		if(!valueIpv4AddrPoolsIpv4AddrPool["Name"].isNull())
+			ipv4AddrPoolsObject.name = valueIpv4AddrPoolsIpv4AddrPool["Name"].asString();
+		if(!valueIpv4AddrPoolsIpv4AddrPool["AddrCount"].isNull())
+			ipv4AddrPoolsObject.addrCount = std::stoi(valueIpv4AddrPoolsIpv4AddrPool["AddrCount"].asString());
+		ipv4AddrPools_.push_back(ipv4AddrPoolsObject);
+	}
+	auto allLinesNode = value["Lines"]["Line"];
+	for (auto valueLinesLine : allLinesNode)
+	{
+		Line linesObject;
+		if(!valueLinesLine["LineCode"].isNull())
+			linesObject.lineCode = valueLinesLine["LineCode"].asString();
+		if(!valueLinesLine["LineName"].isNull())
+			linesObject.lineName = valueLinesLine["LineName"].asString();
+		if(!valueLinesLine["GroupCode"].isNull())
+			linesObject.groupCode = valueLinesLine["GroupCode"].asString();
+		if(!valueLinesLine["GroupName"].isNull())
+			linesObject.groupName = valueLinesLine["GroupName"].asString();
+		if(!valueLinesLine["FatherCode"].isNull())
+			linesObject.fatherCode = valueLinesLine["FatherCode"].asString();
+		lines_.push_back(linesObject);
+	}
+	auto allIpv6AddrPoolsNode = value["Ipv6AddrPools"]["Ipv6AddrPool"];
+	for (auto valueIpv6AddrPoolsIpv6AddrPool : allIpv6AddrPoolsNode)
+	{
+		Ipv6AddrPool ipv6AddrPoolsObject;
+		if(!valueIpv6AddrPoolsIpv6AddrPool["Id"].isNull())
+			ipv6AddrPoolsObject.id = valueIpv6AddrPoolsIpv6AddrPool["Id"].asString();
+		if(!valueIpv6AddrPoolsIpv6AddrPool["Name"].isNull())
+			ipv6AddrPoolsObject.name = valueIpv6AddrPoolsIpv6AddrPool["Name"].asString();
+		if(!valueIpv6AddrPoolsIpv6AddrPool["AddrCount"].isNull())
+			ipv6AddrPoolsObject.addrCount = std::stoi(valueIpv6AddrPoolsIpv6AddrPool["AddrCount"].asString());
+		ipv6AddrPools_.push_back(ipv6AddrPoolsObject);
+	}
+	auto allDomainAddrPoolsNode = value["DomainAddrPools"]["DomainAddrPool"];
+	for (auto valueDomainAddrPoolsDomainAddrPool : allDomainAddrPoolsNode)
+	{
+		DomainAddrPool domainAddrPoolsObject;
+		if(!valueDomainAddrPoolsDomainAddrPool["Id"].isNull())
+			domainAddrPoolsObject.id = valueDomainAddrPoolsDomainAddrPool["Id"].asString();
+		if(!valueDomainAddrPoolsDomainAddrPool["Name"].isNull())
+			domainAddrPoolsObject.name = valueDomainAddrPoolsDomainAddrPool["Name"].asString();
+		if(!valueDomainAddrPoolsDomainAddrPool["AddrCount"].isNull())
+			domainAddrPoolsObject.addrCount = std::stoi(valueDomainAddrPoolsDomainAddrPool["AddrCount"].asString());
+		domainAddrPools_.push_back(domainAddrPoolsObject);
+	}
+	if(!value["SuggestSetDefaultLine"].isNull())
+		suggestSetDefaultLine_ = value["SuggestSetDefaultLine"].asString() == "true";
+
+}
+
+std::vector<DescribeDnsGtmAccessStrategyAvailableConfigResult::Ipv4AddrPool> DescribeDnsGtmAccessStrategyAvailableConfigResult::getIpv4AddrPools()const
+{
+	return ipv4AddrPools_;
+}
+
+std::vector<DescribeDnsGtmAccessStrategyAvailableConfigResult::DomainAddrPool> DescribeDnsGtmAccessStrategyAvailableConfigResult::getDomainAddrPools()const
+{
+	return domainAddrPools_;
+}
+
+std::vector<DescribeDnsGtmAccessStrategyAvailableConfigResult::Ipv6AddrPool> DescribeDnsGtmAccessStrategyAvailableConfigResult::getIpv6AddrPools()const
+{
+	return ipv6AddrPools_;
+}
+
+std::vector<DescribeDnsGtmAccessStrategyAvailableConfigResult::Line> DescribeDnsGtmAccessStrategyAvailableConfigResult::getLines()const
+{
+	return lines_;
+}
+
+bool DescribeDnsGtmAccessStrategyAvailableConfigResult::getSuggestSetDefaultLine()const
+{
+	return suggestSetDefaultLine_;
+}
+

alidns/src/model/DescribeDnsGtmAccessStrategyRequest.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/alidns/model/DescribeDnsGtmAccessStrategyRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmAccessStrategyRequest;
+
+DescribeDnsGtmAccessStrategyRequest::DescribeDnsGtmAccessStrategyRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmAccessStrategy")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmAccessStrategyRequest::~DescribeDnsGtmAccessStrategyRequest()
+{}
+
+std::string DescribeDnsGtmAccessStrategyRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmAccessStrategyRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DescribeDnsGtmAccessStrategyRequest::getStrategyId()const
+{
+	return strategyId_;
+}
+
+void DescribeDnsGtmAccessStrategyRequest::setStrategyId(const std::string& strategyId)
+{
+	strategyId_ = strategyId;
+	setParameter("StrategyId", strategyId);
+}
+
+std::string DescribeDnsGtmAccessStrategyRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmAccessStrategyRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/DescribeDnsGtmAccessStrategyResult.cc

@@ -0,0 +1,255 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/DescribeDnsGtmAccessStrategyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmAccessStrategyResult::DescribeDnsGtmAccessStrategyResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmAccessStrategyResult::DescribeDnsGtmAccessStrategyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmAccessStrategyResult::~DescribeDnsGtmAccessStrategyResult()
+{}
+
+void DescribeDnsGtmAccessStrategyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allLinesNode = value["Lines"]["Line"];
+	for (auto valueLinesLine : allLinesNode)
+	{
+		Line linesObject;
+		if(!valueLinesLine["LineCode"].isNull())
+			linesObject.lineCode = valueLinesLine["LineCode"].asString();
+		if(!valueLinesLine["LineName"].isNull())
+			linesObject.lineName = valueLinesLine["LineName"].asString();
+		if(!valueLinesLine["GroupCode"].isNull())
+			linesObject.groupCode = valueLinesLine["GroupCode"].asString();
+		if(!valueLinesLine["GroupName"].isNull())
+			linesObject.groupName = valueLinesLine["GroupName"].asString();
+		lines_.push_back(linesObject);
+	}
+	auto allDefaultAddrPoolsNode = value["DefaultAddrPools"]["DefaultAddrPool"];
+	for (auto valueDefaultAddrPoolsDefaultAddrPool : allDefaultAddrPoolsNode)
+	{
+		DefaultAddrPool defaultAddrPoolsObject;
+		if(!valueDefaultAddrPoolsDefaultAddrPool["Id"].isNull())
+			defaultAddrPoolsObject.id = valueDefaultAddrPoolsDefaultAddrPool["Id"].asString();
+		if(!valueDefaultAddrPoolsDefaultAddrPool["Name"].isNull())
+			defaultAddrPoolsObject.name = valueDefaultAddrPoolsDefaultAddrPool["Name"].asString();
+		if(!valueDefaultAddrPoolsDefaultAddrPool["AddrCount"].isNull())
+			defaultAddrPoolsObject.addrCount = std::stoi(valueDefaultAddrPoolsDefaultAddrPool["AddrCount"].asString());
+		if(!valueDefaultAddrPoolsDefaultAddrPool["LbaWeight"].isNull())
+			defaultAddrPoolsObject.lbaWeight = std::stoi(valueDefaultAddrPoolsDefaultAddrPool["LbaWeight"].asString());
+		defaultAddrPools_.push_back(defaultAddrPoolsObject);
+	}
+	auto allFailoverAddrPoolsNode = value["FailoverAddrPools"]["FailoverAddrPool"];
+	for (auto valueFailoverAddrPoolsFailoverAddrPool : allFailoverAddrPoolsNode)
+	{
+		FailoverAddrPool failoverAddrPoolsObject;
+		if(!valueFailoverAddrPoolsFailoverAddrPool["Id"].isNull())
+			failoverAddrPoolsObject.id = valueFailoverAddrPoolsFailoverAddrPool["Id"].asString();
+		if(!valueFailoverAddrPoolsFailoverAddrPool["Name"].isNull())
+			failoverAddrPoolsObject.name = valueFailoverAddrPoolsFailoverAddrPool["Name"].asString();
+		if(!valueFailoverAddrPoolsFailoverAddrPool["AddrCount"].isNull())
+			failoverAddrPoolsObject.addrCount = std::stoi(valueFailoverAddrPoolsFailoverAddrPool["AddrCount"].asString());
+		if(!valueFailoverAddrPoolsFailoverAddrPool["LbaWeight"].isNull())
+			failoverAddrPoolsObject.lbaWeight = std::stoi(valueFailoverAddrPoolsFailoverAddrPool["LbaWeight"].asString());
+		failoverAddrPools_.push_back(failoverAddrPoolsObject);
+	}
+	if(!value["StrategyId"].isNull())
+		strategyId_ = value["StrategyId"].asString();
+	if(!value["StrategyName"].isNull())
+		strategyName_ = value["StrategyName"].asString();
+	if(!value["StrategyMode"].isNull())
+		strategyMode_ = value["StrategyMode"].asString();
+	if(!value["InstanceId"].isNull())
+		instanceId_ = value["InstanceId"].asString();
+	if(!value["DefaultAddrPoolType"].isNull())
+		defaultAddrPoolType_ = value["DefaultAddrPoolType"].asString();
+	if(!value["DefaultLbaStrategy"].isNull())
+		defaultLbaStrategy_ = value["DefaultLbaStrategy"].asString();
+	if(!value["DefaultMinAvailableAddrNum"].isNull())
+		defaultMinAvailableAddrNum_ = std::stoi(value["DefaultMinAvailableAddrNum"].asString());
+	if(!value["DefaultMaxReturnAddrNum"].isNull())
+		defaultMaxReturnAddrNum_ = std::stoi(value["DefaultMaxReturnAddrNum"].asString());
+	if(!value["DefaultLatencyOptimization"].isNull())
+		defaultLatencyOptimization_ = value["DefaultLatencyOptimization"].asString();
+	if(!value["DefaultAddrPoolGroupStatus"].isNull())
+		defaultAddrPoolGroupStatus_ = value["DefaultAddrPoolGroupStatus"].asString();
+	if(!value["FailoverAddrPoolType"].isNull())
+		failoverAddrPoolType_ = value["FailoverAddrPoolType"].asString();
+	if(!value["FailoverLbaStrategy"].isNull())
+		failoverLbaStrategy_ = value["FailoverLbaStrategy"].asString();
+	if(!value["FailoverMinAvailableAddrNum"].isNull())
+		failoverMinAvailableAddrNum_ = std::stoi(value["FailoverMinAvailableAddrNum"].asString());
+	if(!value["FailoverMaxReturnAddrNum"].isNull())
+		failoverMaxReturnAddrNum_ = std::stoi(value["FailoverMaxReturnAddrNum"].asString());
+	if(!value["FailoverLatencyOptimization"].isNull())
+		failoverLatencyOptimization_ = value["FailoverLatencyOptimization"].asString();
+	if(!value["FailoverAddrPoolGroupStatus"].isNull())
+		failoverAddrPoolGroupStatus_ = value["FailoverAddrPoolGroupStatus"].asString();
+	if(!value["AccessMode"].isNull())
+		accessMode_ = value["AccessMode"].asString();
+	if(!value["EffectiveAddrPoolGroupType"].isNull())
+		effectiveAddrPoolGroupType_ = value["EffectiveAddrPoolGroupType"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["CreateTimestamp"].isNull())
+		createTimestamp_ = std::stol(value["CreateTimestamp"].asString());
+	if(!value["DefaultAvailableAddrNum"].isNull())
+		defaultAvailableAddrNum_ = std::stoi(value["DefaultAvailableAddrNum"].asString());
+	if(!value["FailoverAvailableAddrNum"].isNull())
+		failoverAvailableAddrNum_ = std::stoi(value["FailoverAvailableAddrNum"].asString());
+
+}
+
+int DescribeDnsGtmAccessStrategyResult::getFailoverMinAvailableAddrNum()const
+{
+	return failoverMinAvailableAddrNum_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getDefaultAddrPoolType()const
+{
+	return defaultAddrPoolType_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getStrategyId()const
+{
+	return strategyId_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getFailoverAddrPoolGroupStatus()const
+{
+	return failoverAddrPoolGroupStatus_;
+}
+
+int DescribeDnsGtmAccessStrategyResult::getDefaultAvailableAddrNum()const
+{
+	return defaultAvailableAddrNum_;
+}
+
+int DescribeDnsGtmAccessStrategyResult::getFailoverAvailableAddrNum()const
+{
+	return failoverAvailableAddrNum_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getFailoverLbaStrategy()const
+{
+	return failoverLbaStrategy_;
+}
+
+int DescribeDnsGtmAccessStrategyResult::getDefaultMaxReturnAddrNum()const
+{
+	return defaultMaxReturnAddrNum_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getStrategyMode()const
+{
+	return strategyMode_;
+}
+
+long DescribeDnsGtmAccessStrategyResult::getCreateTimestamp()const
+{
+	return createTimestamp_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getDefaultLbaStrategy()const
+{
+	return defaultLbaStrategy_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getDefaultAddrPoolGroupStatus()const
+{
+	return defaultAddrPoolGroupStatus_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getFailoverAddrPoolType()const
+{
+	return failoverAddrPoolType_;
+}
+
+std::vector<DescribeDnsGtmAccessStrategyResult::FailoverAddrPool> DescribeDnsGtmAccessStrategyResult::getFailoverAddrPools()const
+{
+	return failoverAddrPools_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getInstanceId()const
+{
+	return instanceId_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getDefaultLatencyOptimization()const
+{
+	return defaultLatencyOptimization_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getEffectiveAddrPoolGroupType()const
+{
+	return effectiveAddrPoolGroupType_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::vector<DescribeDnsGtmAccessStrategyResult::DefaultAddrPool> DescribeDnsGtmAccessStrategyResult::getDefaultAddrPools()const
+{
+	return defaultAddrPools_;
+}
+
+int DescribeDnsGtmAccessStrategyResult::getDefaultMinAvailableAddrNum()const
+{
+	return defaultMinAvailableAddrNum_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getFailoverLatencyOptimization()const
+{
+	return failoverLatencyOptimization_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getStrategyName()const
+{
+	return strategyName_;
+}
+
+int DescribeDnsGtmAccessStrategyResult::getFailoverMaxReturnAddrNum()const
+{
+	return failoverMaxReturnAddrNum_;
+}
+
+std::string DescribeDnsGtmAccessStrategyResult::getAccessMode()const
+{
+	return accessMode_;
+}
+
+std::vector<DescribeDnsGtmAccessStrategyResult::Line> DescribeDnsGtmAccessStrategyResult::getLines()const
+{
+	return lines_;
+}
+

alidns/src/model/DescribeDnsGtmAddrAttributeInfoRequest.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/alidns/model/DescribeDnsGtmAddrAttributeInfoRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmAddrAttributeInfoRequest;
+
+DescribeDnsGtmAddrAttributeInfoRequest::DescribeDnsGtmAddrAttributeInfoRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmAddrAttributeInfo")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmAddrAttributeInfoRequest::~DescribeDnsGtmAddrAttributeInfoRequest()
+{}
+
+std::string DescribeDnsGtmAddrAttributeInfoRequest::getAddrs()const
+{
+	return addrs_;
+}
+
+void DescribeDnsGtmAddrAttributeInfoRequest::setAddrs(const std::string& addrs)
+{
+	addrs_ = addrs;
+	setParameter("Addrs", addrs);
+}
+
+std::string DescribeDnsGtmAddrAttributeInfoRequest::getType()const
+{
+	return type_;
+}
+
+void DescribeDnsGtmAddrAttributeInfoRequest::setType(const std::string& type)
+{
+	type_ = type;
+	setParameter("Type", type);
+}
+
+std::string DescribeDnsGtmAddrAttributeInfoRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmAddrAttributeInfoRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DescribeDnsGtmAddrAttributeInfoRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmAddrAttributeInfoRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/DescribeDnsGtmAddrAttributeInfoResult.cc

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/alidns/model/DescribeDnsGtmAddrAttributeInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmAddrAttributeInfoResult::DescribeDnsGtmAddrAttributeInfoResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmAddrAttributeInfoResult::DescribeDnsGtmAddrAttributeInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmAddrAttributeInfoResult::~DescribeDnsGtmAddrAttributeInfoResult()
+{}
+
+void DescribeDnsGtmAddrAttributeInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAddrNode = value["Addr"]["AddrItem"];
+	for (auto valueAddrAddrItem : allAddrNode)
+	{
+		AddrItem addrObject;
+		if(!valueAddrAddrItem["Addr"].isNull())
+			addrObject.addr = valueAddrAddrItem["Addr"].asString();
+		auto attributeInfoNode = value["AttributeInfo"];
+		if(!attributeInfoNode["LineCode"].isNull())
+			addrObject.attributeInfo.lineCode = attributeInfoNode["LineCode"].asString();
+		if(!attributeInfoNode["LineName"].isNull())
+			addrObject.attributeInfo.lineName = attributeInfoNode["LineName"].asString();
+		if(!attributeInfoNode["GroupCode"].isNull())
+			addrObject.attributeInfo.groupCode = attributeInfoNode["GroupCode"].asString();
+		if(!attributeInfoNode["GroupName"].isNull())
+			addrObject.attributeInfo.groupName = attributeInfoNode["GroupName"].asString();
+		if(!attributeInfoNode["FatherCode"].isNull())
+			addrObject.attributeInfo.fatherCode = attributeInfoNode["FatherCode"].asString();
+		addr_.push_back(addrObject);
+	}
+
+}
+
+std::vector<DescribeDnsGtmAddrAttributeInfoResult::AddrItem> DescribeDnsGtmAddrAttributeInfoResult::getAddr()const
+{
+	return addr_;
+}
+

alidns/src/model/DescribeDnsGtmAddressPoolAvailableConfigRequest.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/alidns/model/DescribeDnsGtmAddressPoolAvailableConfigRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmAddressPoolAvailableConfigRequest;
+
+DescribeDnsGtmAddressPoolAvailableConfigRequest::DescribeDnsGtmAddressPoolAvailableConfigRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmAddressPoolAvailableConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmAddressPoolAvailableConfigRequest::~DescribeDnsGtmAddressPoolAvailableConfigRequest()
+{}
+
+std::string DescribeDnsGtmAddressPoolAvailableConfigRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeDnsGtmAddressPoolAvailableConfigRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string DescribeDnsGtmAddressPoolAvailableConfigRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmAddressPoolAvailableConfigRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DescribeDnsGtmAddressPoolAvailableConfigRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmAddressPoolAvailableConfigRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/DescribeDnsGtmAddressPoolAvailableConfigResult.cc

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/alidns/model/DescribeDnsGtmAddressPoolAvailableConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmAddressPoolAvailableConfigResult::DescribeDnsGtmAddressPoolAvailableConfigResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmAddressPoolAvailableConfigResult::DescribeDnsGtmAddressPoolAvailableConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmAddressPoolAvailableConfigResult::~DescribeDnsGtmAddressPoolAvailableConfigResult()
+{}
+
+void DescribeDnsGtmAddressPoolAvailableConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAttributeInfosNode = value["AttributeInfos"]["AttributeInfo"];
+	for (auto valueAttributeInfosAttributeInfo : allAttributeInfosNode)
+	{
+		AttributeInfo attributeInfosObject;
+		if(!valueAttributeInfosAttributeInfo["LineCode"].isNull())
+			attributeInfosObject.lineCode = valueAttributeInfosAttributeInfo["LineCode"].asString();
+		if(!valueAttributeInfosAttributeInfo["LineName"].isNull())
+			attributeInfosObject.lineName = valueAttributeInfosAttributeInfo["LineName"].asString();
+		if(!valueAttributeInfosAttributeInfo["GroupCode"].isNull())
+			attributeInfosObject.groupCode = valueAttributeInfosAttributeInfo["GroupCode"].asString();
+		if(!valueAttributeInfosAttributeInfo["GroupName"].isNull())
+			attributeInfosObject.groupName = valueAttributeInfosAttributeInfo["GroupName"].asString();
+		if(!valueAttributeInfosAttributeInfo["FatherCode"].isNull())
+			attributeInfosObject.fatherCode = valueAttributeInfosAttributeInfo["FatherCode"].asString();
+		attributeInfos_.push_back(attributeInfosObject);
+	}
+
+}
+
+std::vector<DescribeDnsGtmAddressPoolAvailableConfigResult::AttributeInfo> DescribeDnsGtmAddressPoolAvailableConfigResult::getAttributeInfos()const
+{
+	return attributeInfos_;
+}
+

alidns/src/model/DescribeDnsGtmAvailableAlertGroupRequest.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/alidns/model/DescribeDnsGtmAvailableAlertGroupRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmAvailableAlertGroupRequest;
+
+DescribeDnsGtmAvailableAlertGroupRequest::DescribeDnsGtmAvailableAlertGroupRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmAvailableAlertGroup")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmAvailableAlertGroupRequest::~DescribeDnsGtmAvailableAlertGroupRequest()
+{}
+
+std::string DescribeDnsGtmAvailableAlertGroupRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmAvailableAlertGroupRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DescribeDnsGtmAvailableAlertGroupRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmAvailableAlertGroupRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

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

alidns/src/model/DescribeDnsGtmInstanceAddressPoolRequest.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/alidns/model/DescribeDnsGtmInstanceAddressPoolRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmInstanceAddressPoolRequest;
+
+DescribeDnsGtmInstanceAddressPoolRequest::DescribeDnsGtmInstanceAddressPoolRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmInstanceAddressPool")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmInstanceAddressPoolRequest::~DescribeDnsGtmInstanceAddressPoolRequest()
+{}
+
+std::string DescribeDnsGtmInstanceAddressPoolRequest::getAddrPoolId()const
+{
+	return addrPoolId_;
+}
+
+void DescribeDnsGtmInstanceAddressPoolRequest::setAddrPoolId(const std::string& addrPoolId)
+{
+	addrPoolId_ = addrPoolId;
+	setParameter("AddrPoolId", addrPoolId);
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmInstanceAddressPoolRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmInstanceAddressPoolRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/DescribeDnsGtmInstanceAddressPoolResult.cc

@@ -0,0 +1,152 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/DescribeDnsGtmInstanceAddressPoolResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmInstanceAddressPoolResult::DescribeDnsGtmInstanceAddressPoolResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmInstanceAddressPoolResult::DescribeDnsGtmInstanceAddressPoolResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmInstanceAddressPoolResult::~DescribeDnsGtmInstanceAddressPoolResult()
+{}
+
+void DescribeDnsGtmInstanceAddressPoolResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAddrsNode = value["Addrs"]["Addr"];
+	for (auto valueAddrsAddr : allAddrsNode)
+	{
+		Addr addrsObject;
+		if(!valueAddrsAddr["CreateTime"].isNull())
+			addrsObject.createTime = valueAddrsAddr["CreateTime"].asString();
+		if(!valueAddrsAddr["CreateTimestamp"].isNull())
+			addrsObject.createTimestamp = std::stol(valueAddrsAddr["CreateTimestamp"].asString());
+		if(!valueAddrsAddr["UpdateTime"].isNull())
+			addrsObject.updateTime = valueAddrsAddr["UpdateTime"].asString();
+		if(!valueAddrsAddr["UpdateTimestamp"].isNull())
+			addrsObject.updateTimestamp = std::stol(valueAddrsAddr["UpdateTimestamp"].asString());
+		if(!valueAddrsAddr["Addr"].isNull())
+			addrsObject.addr = valueAddrsAddr["Addr"].asString();
+		if(!valueAddrsAddr["LbaWeight"].isNull())
+			addrsObject.lbaWeight = std::stoi(valueAddrsAddr["LbaWeight"].asString());
+		if(!valueAddrsAddr["Mode"].isNull())
+			addrsObject.mode = valueAddrsAddr["Mode"].asString();
+		if(!valueAddrsAddr["AlertStatus"].isNull())
+			addrsObject.alertStatus = valueAddrsAddr["AlertStatus"].asString();
+		if(!valueAddrsAddr["Remark"].isNull())
+			addrsObject.remark = valueAddrsAddr["Remark"].asString();
+		if(!valueAddrsAddr["AttributeInfo"].isNull())
+			addrsObject.attributeInfo = valueAddrsAddr["AttributeInfo"].asString();
+		addrs_.push_back(addrsObject);
+	}
+	if(!value["AddrPoolId"].isNull())
+		addrPoolId_ = value["AddrPoolId"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["CreateTimestamp"].isNull())
+		createTimestamp_ = std::stol(value["CreateTimestamp"].asString());
+	if(!value["UpdateTime"].isNull())
+		updateTime_ = value["UpdateTime"].asString();
+	if(!value["UpdateTimestamp"].isNull())
+		updateTimestamp_ = std::stol(value["UpdateTimestamp"].asString());
+	if(!value["AddrCount"].isNull())
+		addrCount_ = std::stoi(value["AddrCount"].asString());
+	if(!value["MonitorConfigId"].isNull())
+		monitorConfigId_ = value["MonitorConfigId"].asString();
+	if(!value["MonitorStatus"].isNull())
+		monitorStatus_ = value["MonitorStatus"].asString();
+	if(!value["Name"].isNull())
+		name_ = value["Name"].asString();
+	if(!value["Type"].isNull())
+		type_ = value["Type"].asString();
+	if(!value["LbaStrategy"].isNull())
+		lbaStrategy_ = value["LbaStrategy"].asString();
+
+}
+
+std::vector<DescribeDnsGtmInstanceAddressPoolResult::Addr> DescribeDnsGtmInstanceAddressPoolResult::getAddrs()const
+{
+	return addrs_;
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolResult::getType()const
+{
+	return type_;
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolResult::getLbaStrategy()const
+{
+	return lbaStrategy_;
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolResult::getAddrPoolId()const
+{
+	return addrPoolId_;
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolResult::getUpdateTime()const
+{
+	return updateTime_;
+}
+
+long DescribeDnsGtmInstanceAddressPoolResult::getUpdateTimestamp()const
+{
+	return updateTimestamp_;
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolResult::getMonitorConfigId()const
+{
+	return monitorConfigId_;
+}
+
+long DescribeDnsGtmInstanceAddressPoolResult::getCreateTimestamp()const
+{
+	return createTimestamp_;
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolResult::getMonitorStatus()const
+{
+	return monitorStatus_;
+}
+
+int DescribeDnsGtmInstanceAddressPoolResult::getAddrCount()const
+{
+	return addrCount_;
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolResult::getName()const
+{
+	return name_;
+}
+

alidns/src/model/DescribeDnsGtmInstanceAddressPoolsRequest.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/alidns/model/DescribeDnsGtmInstanceAddressPoolsRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmInstanceAddressPoolsRequest;
+
+DescribeDnsGtmInstanceAddressPoolsRequest::DescribeDnsGtmInstanceAddressPoolsRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmInstanceAddressPools")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmInstanceAddressPoolsRequest::~DescribeDnsGtmInstanceAddressPoolsRequest()
+{}
+
+int DescribeDnsGtmInstanceAddressPoolsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeDnsGtmInstanceAddressPoolsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolsRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeDnsGtmInstanceAddressPoolsRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolsRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmInstanceAddressPoolsRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+int DescribeDnsGtmInstanceAddressPoolsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeDnsGtmInstanceAddressPoolsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeDnsGtmInstanceAddressPoolsRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmInstanceAddressPoolsRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/DescribeDnsGtmInstanceAddressPoolsResult.cc

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/DescribeDnsGtmInstanceAddressPoolsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmInstanceAddressPoolsResult::DescribeDnsGtmInstanceAddressPoolsResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmInstanceAddressPoolsResult::DescribeDnsGtmInstanceAddressPoolsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmInstanceAddressPoolsResult::~DescribeDnsGtmInstanceAddressPoolsResult()
+{}
+
+void DescribeDnsGtmInstanceAddressPoolsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allAddrPoolsNode = value["AddrPools"]["AddrPool"];
+	for (auto valueAddrPoolsAddrPool : allAddrPoolsNode)
+	{
+		AddrPool addrPoolsObject;
+		if(!valueAddrPoolsAddrPool["AddrPoolId"].isNull())
+			addrPoolsObject.addrPoolId = valueAddrPoolsAddrPool["AddrPoolId"].asString();
+		if(!valueAddrPoolsAddrPool["CreateTime"].isNull())
+			addrPoolsObject.createTime = valueAddrPoolsAddrPool["CreateTime"].asString();
+		if(!valueAddrPoolsAddrPool["CreateTimestamp"].isNull())
+			addrPoolsObject.createTimestamp = std::stol(valueAddrPoolsAddrPool["CreateTimestamp"].asString());
+		if(!valueAddrPoolsAddrPool["UpdateTime"].isNull())
+			addrPoolsObject.updateTime = valueAddrPoolsAddrPool["UpdateTime"].asString();
+		if(!valueAddrPoolsAddrPool["UpdateTimestamp"].isNull())
+			addrPoolsObject.updateTimestamp = std::stol(valueAddrPoolsAddrPool["UpdateTimestamp"].asString());
+		if(!valueAddrPoolsAddrPool["AddrCount"].isNull())
+			addrPoolsObject.addrCount = std::stoi(valueAddrPoolsAddrPool["AddrCount"].asString());
+		if(!valueAddrPoolsAddrPool["MonitorConfigId"].isNull())
+			addrPoolsObject.monitorConfigId = valueAddrPoolsAddrPool["MonitorConfigId"].asString();
+		if(!valueAddrPoolsAddrPool["MonitorStatus"].isNull())
+			addrPoolsObject.monitorStatus = valueAddrPoolsAddrPool["MonitorStatus"].asString();
+		if(!valueAddrPoolsAddrPool["Name"].isNull())
+			addrPoolsObject.name = valueAddrPoolsAddrPool["Name"].asString();
+		if(!valueAddrPoolsAddrPool["Type"].isNull())
+			addrPoolsObject.type = valueAddrPoolsAddrPool["Type"].asString();
+		if(!valueAddrPoolsAddrPool["LbaStrategy"].isNull())
+			addrPoolsObject.lbaStrategy = valueAddrPoolsAddrPool["LbaStrategy"].asString();
+		addrPools_.push_back(addrPoolsObject);
+	}
+	if(!value["TotalItems"].isNull())
+		totalItems_ = std::stoi(value["TotalItems"].asString());
+	if(!value["TotalPages"].isNull())
+		totalPages_ = std::stoi(value["TotalPages"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+
+}
+
+int DescribeDnsGtmInstanceAddressPoolsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeDnsGtmInstanceAddressPoolsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+int DescribeDnsGtmInstanceAddressPoolsResult::getTotalPages()const
+{
+	return totalPages_;
+}
+
+int DescribeDnsGtmInstanceAddressPoolsResult::getTotalItems()const
+{
+	return totalItems_;
+}
+
+std::vector<DescribeDnsGtmInstanceAddressPoolsResult::AddrPool> DescribeDnsGtmInstanceAddressPoolsResult::getAddrPools()const
+{
+	return addrPools_;
+}
+

alidns/src/model/DescribeDnsGtmInstanceRequest.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/alidns/model/DescribeDnsGtmInstanceRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmInstanceRequest;
+
+DescribeDnsGtmInstanceRequest::DescribeDnsGtmInstanceRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmInstance")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmInstanceRequest::~DescribeDnsGtmInstanceRequest()
+{}
+
+std::string DescribeDnsGtmInstanceRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeDnsGtmInstanceRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string DescribeDnsGtmInstanceRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmInstanceRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DescribeDnsGtmInstanceRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmInstanceRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/DescribeDnsGtmInstanceResult.cc

@@ -0,0 +1,160 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/DescribeDnsGtmInstanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmInstanceResult::DescribeDnsGtmInstanceResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmInstanceResult::DescribeDnsGtmInstanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmInstanceResult::~DescribeDnsGtmInstanceResult()
+{}
+
+void DescribeDnsGtmInstanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto configNode = value["Config"];
+	if(!configNode["InstanceName"].isNull())
+		config_.instanceName = configNode["InstanceName"].asString();
+	if(!configNode["CnameType"].isNull())
+		config_.cnameType = configNode["CnameType"].asString();
+	if(!configNode["PublicUserDomainName"].isNull())
+		config_.publicUserDomainName = configNode["PublicUserDomainName"].asString();
+	if(!configNode["PublicCnameMode"].isNull())
+		config_.publicCnameMode = configNode["PublicCnameMode"].asString();
+	if(!configNode["PubicZoneName"].isNull())
+		config_.pubicZoneName = configNode["PubicZoneName"].asString();
+	if(!configNode["Ttl"].isNull())
+		config_.ttl = std::stoi(configNode["Ttl"].asString());
+	if(!configNode["StrategyMode"].isNull())
+		config_.strategyMode = configNode["StrategyMode"].asString();
+	if(!configNode["AlertGroup"].isNull())
+		config_.alertGroup = configNode["AlertGroup"].asString();
+	auto allAlertConfigNode = configNode["AlertConfig"]["AlertConfigItem"];
+	for (auto configNodeAlertConfigAlertConfigItem : allAlertConfigNode)
+	{
+		Config::AlertConfigItem alertConfigItemObject;
+		if(!configNodeAlertConfigAlertConfigItem["NoticeType"].isNull())
+			alertConfigItemObject.noticeType = configNodeAlertConfigAlertConfigItem["NoticeType"].asString();
+		if(!configNodeAlertConfigAlertConfigItem["SmsNotice"].isNull())
+			alertConfigItemObject.smsNotice = configNodeAlertConfigAlertConfigItem["SmsNotice"].asString() == "true";
+		if(!configNodeAlertConfigAlertConfigItem["EmailNotice"].isNull())
+			alertConfigItemObject.emailNotice = configNodeAlertConfigAlertConfigItem["EmailNotice"].asString() == "true";
+		config_.alertConfig.push_back(alertConfigItemObject);
+	}
+	auto usedQuotaNode = value["UsedQuota"];
+	if(!usedQuotaNode["TaskUsedCount"].isNull())
+		usedQuota_.taskUsedCount = std::stoi(usedQuotaNode["TaskUsedCount"].asString());
+	if(!usedQuotaNode["SmsUsedCount"].isNull())
+		usedQuota_.smsUsedCount = std::stoi(usedQuotaNode["SmsUsedCount"].asString());
+	if(!usedQuotaNode["EmailUsedCount"].isNull())
+		usedQuota_.emailUsedCount = std::stoi(usedQuotaNode["EmailUsedCount"].asString());
+	if(!value["InstanceId"].isNull())
+		instanceId_ = value["InstanceId"].asString();
+	if(!value["VersionCode"].isNull())
+		versionCode_ = value["VersionCode"].asString();
+	if(!value["SmsQuota"].isNull())
+		smsQuota_ = std::stoi(value["SmsQuota"].asString());
+	if(!value["TaskQuota"].isNull())
+		taskQuota_ = std::stoi(value["TaskQuota"].asString());
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["CreateTimestamp"].isNull())
+		createTimestamp_ = std::stol(value["CreateTimestamp"].asString());
+	if(!value["ExpireTime"].isNull())
+		expireTime_ = value["ExpireTime"].asString();
+	if(!value["ExpireTimestamp"].isNull())
+		expireTimestamp_ = std::stol(value["ExpireTimestamp"].asString());
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
+	if(!value["PaymentType"].isNull())
+		paymentType_ = value["PaymentType"].asString();
+
+}
+
+std::string DescribeDnsGtmInstanceResult::getVersionCode()const
+{
+	return versionCode_;
+}
+
+long DescribeDnsGtmInstanceResult::getExpireTimestamp()const
+{
+	return expireTimestamp_;
+}
+
+std::string DescribeDnsGtmInstanceResult::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+std::string DescribeDnsGtmInstanceResult::getInstanceId()const
+{
+	return instanceId_;
+}
+
+DescribeDnsGtmInstanceResult::Config DescribeDnsGtmInstanceResult::getConfig()const
+{
+	return config_;
+}
+
+int DescribeDnsGtmInstanceResult::getTaskQuota()const
+{
+	return taskQuota_;
+}
+
+std::string DescribeDnsGtmInstanceResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string DescribeDnsGtmInstanceResult::getPaymentType()const
+{
+	return paymentType_;
+}
+
+std::string DescribeDnsGtmInstanceResult::getExpireTime()const
+{
+	return expireTime_;
+}
+
+DescribeDnsGtmInstanceResult::UsedQuota DescribeDnsGtmInstanceResult::getUsedQuota()const
+{
+	return usedQuota_;
+}
+
+int DescribeDnsGtmInstanceResult::getSmsQuota()const
+{
+	return smsQuota_;
+}
+
+long DescribeDnsGtmInstanceResult::getCreateTimestamp()const
+{
+	return createTimestamp_;
+}
+

alidns/src/model/DescribeDnsGtmInstanceStatusRequest.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/alidns/model/DescribeDnsGtmInstanceStatusRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmInstanceStatusRequest;
+
+DescribeDnsGtmInstanceStatusRequest::DescribeDnsGtmInstanceStatusRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmInstanceStatus")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmInstanceStatusRequest::~DescribeDnsGtmInstanceStatusRequest()
+{}
+
+std::string DescribeDnsGtmInstanceStatusRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeDnsGtmInstanceStatusRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string DescribeDnsGtmInstanceStatusRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmInstanceStatusRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DescribeDnsGtmInstanceStatusRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmInstanceStatusRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/DescribeDnsGtmInstanceStatusResult.cc

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

alidns/src/model/DescribeDnsGtmInstanceSystemCnameRequest.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/alidns/model/DescribeDnsGtmInstanceSystemCnameRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmInstanceSystemCnameRequest;
+
+DescribeDnsGtmInstanceSystemCnameRequest::DescribeDnsGtmInstanceSystemCnameRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmInstanceSystemCname")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmInstanceSystemCnameRequest::~DescribeDnsGtmInstanceSystemCnameRequest()
+{}
+
+std::string DescribeDnsGtmInstanceSystemCnameRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeDnsGtmInstanceSystemCnameRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string DescribeDnsGtmInstanceSystemCnameRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmInstanceSystemCnameRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DescribeDnsGtmInstanceSystemCnameRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmInstanceSystemCnameRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

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

alidns/src/model/DescribeDnsGtmInstancesRequest.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/alidns/model/DescribeDnsGtmInstancesRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmInstancesRequest;
+
+DescribeDnsGtmInstancesRequest::DescribeDnsGtmInstancesRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmInstances")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmInstancesRequest::~DescribeDnsGtmInstancesRequest()
+{}
+
+int DescribeDnsGtmInstancesRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeDnsGtmInstancesRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeDnsGtmInstancesRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void DescribeDnsGtmInstancesRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
+std::string DescribeDnsGtmInstancesRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmInstancesRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+int DescribeDnsGtmInstancesRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeDnsGtmInstancesRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeDnsGtmInstancesRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmInstancesRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::string DescribeDnsGtmInstancesRequest::getKeyword()const
+{
+	return keyword_;
+}
+
+void DescribeDnsGtmInstancesRequest::setKeyword(const std::string& keyword)
+{
+	keyword_ = keyword;
+	setParameter("Keyword", keyword);
+}
+

alidns/src/model/DescribeDnsGtmInstancesResult.cc

@@ -0,0 +1,139 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/DescribeDnsGtmInstancesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmInstancesResult::DescribeDnsGtmInstancesResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmInstancesResult::DescribeDnsGtmInstancesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmInstancesResult::~DescribeDnsGtmInstancesResult()
+{}
+
+void DescribeDnsGtmInstancesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allGtmInstancesNode = value["GtmInstances"]["GtmInstance"];
+	for (auto valueGtmInstancesGtmInstance : allGtmInstancesNode)
+	{
+		GtmInstance gtmInstancesObject;
+		if(!valueGtmInstancesGtmInstance["InstanceId"].isNull())
+			gtmInstancesObject.instanceId = valueGtmInstancesGtmInstance["InstanceId"].asString();
+		if(!valueGtmInstancesGtmInstance["VersionCode"].isNull())
+			gtmInstancesObject.versionCode = valueGtmInstancesGtmInstance["VersionCode"].asString();
+		if(!valueGtmInstancesGtmInstance["SmsQuota"].isNull())
+			gtmInstancesObject.smsQuota = std::stoi(valueGtmInstancesGtmInstance["SmsQuota"].asString());
+		if(!valueGtmInstancesGtmInstance["CreateTime"].isNull())
+			gtmInstancesObject.createTime = valueGtmInstancesGtmInstance["CreateTime"].asString();
+		if(!valueGtmInstancesGtmInstance["CreateTimestamp"].isNull())
+			gtmInstancesObject.createTimestamp = std::stol(valueGtmInstancesGtmInstance["CreateTimestamp"].asString());
+		if(!valueGtmInstancesGtmInstance["ExpireTime"].isNull())
+			gtmInstancesObject.expireTime = valueGtmInstancesGtmInstance["ExpireTime"].asString();
+		if(!valueGtmInstancesGtmInstance["ExpireTimestamp"].isNull())
+			gtmInstancesObject.expireTimestamp = std::stol(valueGtmInstancesGtmInstance["ExpireTimestamp"].asString());
+		if(!valueGtmInstancesGtmInstance["TaskQuota"].isNull())
+			gtmInstancesObject.taskQuota = std::stoi(valueGtmInstancesGtmInstance["TaskQuota"].asString());
+		if(!valueGtmInstancesGtmInstance["ResourceGroupId"].isNull())
+			gtmInstancesObject.resourceGroupId = valueGtmInstancesGtmInstance["ResourceGroupId"].asString();
+		if(!valueGtmInstancesGtmInstance["PaymentType"].isNull())
+			gtmInstancesObject.paymentType = valueGtmInstancesGtmInstance["PaymentType"].asString();
+		auto configNode = value["Config"];
+		if(!configNode["InstanceName"].isNull())
+			gtmInstancesObject.config.instanceName = configNode["InstanceName"].asString();
+		if(!configNode["CnameType"].isNull())
+			gtmInstancesObject.config.cnameType = configNode["CnameType"].asString();
+		if(!configNode["PublicUserDomainName"].isNull())
+			gtmInstancesObject.config.publicUserDomainName = configNode["PublicUserDomainName"].asString();
+		if(!configNode["PublicCnameMode"].isNull())
+			gtmInstancesObject.config.publicCnameMode = configNode["PublicCnameMode"].asString();
+		if(!configNode["PublicZoneName"].isNull())
+			gtmInstancesObject.config.publicZoneName = configNode["PublicZoneName"].asString();
+		if(!configNode["Ttl"].isNull())
+			gtmInstancesObject.config.ttl = std::stoi(configNode["Ttl"].asString());
+		if(!configNode["AlertGroup"].isNull())
+			gtmInstancesObject.config.alertGroup = configNode["AlertGroup"].asString();
+		if(!configNode["StrategyMode"].isNull())
+			gtmInstancesObject.config.strategyMode = configNode["StrategyMode"].asString();
+		auto allAlertConfigNode = configNode["AlertConfig"]["AlertConfigItem"];
+		for (auto configNodeAlertConfigAlertConfigItem : allAlertConfigNode)
+		{
+			GtmInstance::Config::AlertConfigItem alertConfigItemObject;
+			if(!configNodeAlertConfigAlertConfigItem["NoticeType"].isNull())
+				alertConfigItemObject.noticeType = configNodeAlertConfigAlertConfigItem["NoticeType"].asString();
+			if(!configNodeAlertConfigAlertConfigItem["SmsNotice"].isNull())
+				alertConfigItemObject.smsNotice = configNodeAlertConfigAlertConfigItem["SmsNotice"].asString();
+			if(!configNodeAlertConfigAlertConfigItem["EmailNotice"].isNull())
+				alertConfigItemObject.emailNotice = configNodeAlertConfigAlertConfigItem["EmailNotice"].asString();
+			gtmInstancesObject.config.alertConfig.push_back(alertConfigItemObject);
+		}
+		auto usedQuotaNode = value["UsedQuota"];
+		if(!usedQuotaNode["TaskUsedCount"].isNull())
+			gtmInstancesObject.usedQuota.taskUsedCount = std::stoi(usedQuotaNode["TaskUsedCount"].asString());
+		if(!usedQuotaNode["SmsUsedCount"].isNull())
+			gtmInstancesObject.usedQuota.smsUsedCount = std::stoi(usedQuotaNode["SmsUsedCount"].asString());
+		if(!usedQuotaNode["EmailUsedCount"].isNull())
+			gtmInstancesObject.usedQuota.emailUsedCount = std::stoi(usedQuotaNode["EmailUsedCount"].asString());
+		gtmInstances_.push_back(gtmInstancesObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalItems"].isNull())
+		totalItems_ = std::stoi(value["TotalItems"].asString());
+	if(!value["TotalPages"].isNull())
+		totalPages_ = std::stoi(value["TotalPages"].asString());
+
+}
+
+int DescribeDnsGtmInstancesResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeDnsGtmInstancesResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeDnsGtmInstancesResult::GtmInstance> DescribeDnsGtmInstancesResult::getGtmInstances()const
+{
+	return gtmInstances_;
+}
+
+int DescribeDnsGtmInstancesResult::getTotalPages()const
+{
+	return totalPages_;
+}
+
+int DescribeDnsGtmInstancesResult::getTotalItems()const
+{
+	return totalItems_;
+}
+

alidns/src/model/DescribeDnsGtmLogsRequest.cc

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/alidns/model/DescribeDnsGtmLogsRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmLogsRequest;
+
+DescribeDnsGtmLogsRequest::DescribeDnsGtmLogsRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmLogs")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmLogsRequest::~DescribeDnsGtmLogsRequest()
+{}
+
+long DescribeDnsGtmLogsRequest::getStartTimestamp()const
+{
+	return startTimestamp_;
+}
+
+void DescribeDnsGtmLogsRequest::setStartTimestamp(long startTimestamp)
+{
+	startTimestamp_ = startTimestamp;
+	setParameter("StartTimestamp", std::to_string(startTimestamp));
+}
+
+int DescribeDnsGtmLogsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeDnsGtmLogsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+long DescribeDnsGtmLogsRequest::getEndTimestamp()const
+{
+	return endTimestamp_;
+}
+
+void DescribeDnsGtmLogsRequest::setEndTimestamp(long endTimestamp)
+{
+	endTimestamp_ = endTimestamp;
+	setParameter("EndTimestamp", std::to_string(endTimestamp));
+}
+
+std::string DescribeDnsGtmLogsRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void DescribeDnsGtmLogsRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string DescribeDnsGtmLogsRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmLogsRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+int DescribeDnsGtmLogsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeDnsGtmLogsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeDnsGtmLogsRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmLogsRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::string DescribeDnsGtmLogsRequest::getKeyword()const
+{
+	return keyword_;
+}
+
+void DescribeDnsGtmLogsRequest::setKeyword(const std::string& keyword)
+{
+	keyword_ = keyword;
+	setParameter("Keyword", keyword);
+}
+

alidns/src/model/DescribeDnsGtmLogsResult.cc

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/DescribeDnsGtmLogsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmLogsResult::DescribeDnsGtmLogsResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmLogsResult::DescribeDnsGtmLogsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmLogsResult::~DescribeDnsGtmLogsResult()
+{}
+
+void DescribeDnsGtmLogsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allLogsNode = value["Logs"]["Log"];
+	for (auto valueLogsLog : allLogsNode)
+	{
+		Log logsObject;
+		if(!valueLogsLog["OperTime"].isNull())
+			logsObject.operTime = valueLogsLog["OperTime"].asString();
+		if(!valueLogsLog["OperAction"].isNull())
+			logsObject.operAction = valueLogsLog["OperAction"].asString();
+		if(!valueLogsLog["EntityType"].isNull())
+			logsObject.entityType = valueLogsLog["EntityType"].asString();
+		if(!valueLogsLog["EntityId"].isNull())
+			logsObject.entityId = valueLogsLog["EntityId"].asString();
+		if(!valueLogsLog["EntityName"].isNull())
+			logsObject.entityName = valueLogsLog["EntityName"].asString();
+		if(!valueLogsLog["OperTimestamp"].isNull())
+			logsObject.operTimestamp = std::stol(valueLogsLog["OperTimestamp"].asString());
+		if(!valueLogsLog["Id"].isNull())
+			logsObject.id = std::stol(valueLogsLog["Id"].asString());
+		if(!valueLogsLog["Content"].isNull())
+			logsObject.content = valueLogsLog["Content"].asString();
+		logs_.push_back(logsObject);
+	}
+	if(!value["TotalItems"].isNull())
+		totalItems_ = std::stoi(value["TotalItems"].asString());
+	if(!value["TotalPages"].isNull())
+		totalPages_ = std::stoi(value["TotalPages"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+
+}
+
+int DescribeDnsGtmLogsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeDnsGtmLogsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+int DescribeDnsGtmLogsResult::getTotalPages()const
+{
+	return totalPages_;
+}
+
+std::vector<DescribeDnsGtmLogsResult::Log> DescribeDnsGtmLogsResult::getLogs()const
+{
+	return logs_;
+}
+
+int DescribeDnsGtmLogsResult::getTotalItems()const
+{
+	return totalItems_;
+}
+

alidns/src/model/DescribeDnsGtmMonitorAvailableConfigRequest.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/alidns/model/DescribeDnsGtmMonitorAvailableConfigRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmMonitorAvailableConfigRequest;
+
+DescribeDnsGtmMonitorAvailableConfigRequest::DescribeDnsGtmMonitorAvailableConfigRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmMonitorAvailableConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmMonitorAvailableConfigRequest::~DescribeDnsGtmMonitorAvailableConfigRequest()
+{}
+
+std::string DescribeDnsGtmMonitorAvailableConfigRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmMonitorAvailableConfigRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DescribeDnsGtmMonitorAvailableConfigRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmMonitorAvailableConfigRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/DescribeDnsGtmMonitorAvailableConfigResult.cc

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/DescribeDnsGtmMonitorAvailableConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmMonitorAvailableConfigResult::DescribeDnsGtmMonitorAvailableConfigResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmMonitorAvailableConfigResult::DescribeDnsGtmMonitorAvailableConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmMonitorAvailableConfigResult::~DescribeDnsGtmMonitorAvailableConfigResult()
+{}
+
+void DescribeDnsGtmMonitorAvailableConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allIpv4IspCityNodesNode = value["Ipv4IspCityNodes"]["Ipv4IspCityNode"];
+	for (auto valueIpv4IspCityNodesIpv4IspCityNode : allIpv4IspCityNodesNode)
+	{
+		Ipv4IspCityNode ipv4IspCityNodesObject;
+		if(!valueIpv4IspCityNodesIpv4IspCityNode["IspName"].isNull())
+			ipv4IspCityNodesObject.ispName = valueIpv4IspCityNodesIpv4IspCityNode["IspName"].asString();
+		if(!valueIpv4IspCityNodesIpv4IspCityNode["IspCode"].isNull())
+			ipv4IspCityNodesObject.ispCode = valueIpv4IspCityNodesIpv4IspCityNode["IspCode"].asString();
+		if(!valueIpv4IspCityNodesIpv4IspCityNode["CityName"].isNull())
+			ipv4IspCityNodesObject.cityName = valueIpv4IspCityNodesIpv4IspCityNode["CityName"].asString();
+		if(!valueIpv4IspCityNodesIpv4IspCityNode["CityCode"].isNull())
+			ipv4IspCityNodesObject.cityCode = valueIpv4IspCityNodesIpv4IspCityNode["CityCode"].asString();
+		if(!valueIpv4IspCityNodesIpv4IspCityNode["DefaultSelected"].isNull())
+			ipv4IspCityNodesObject.defaultSelected = valueIpv4IspCityNodesIpv4IspCityNode["DefaultSelected"].asString() == "true";
+		if(!valueIpv4IspCityNodesIpv4IspCityNode["GroupType"].isNull())
+			ipv4IspCityNodesObject.groupType = valueIpv4IspCityNodesIpv4IspCityNode["GroupType"].asString();
+		if(!valueIpv4IspCityNodesIpv4IspCityNode["GroupName"].isNull())
+			ipv4IspCityNodesObject.groupName = valueIpv4IspCityNodesIpv4IspCityNode["GroupName"].asString();
+		ipv4IspCityNodes_.push_back(ipv4IspCityNodesObject);
+	}
+	auto allIpv6IspCityNodesNode = value["Ipv6IspCityNodes"]["Ipv6IspCityNode"];
+	for (auto valueIpv6IspCityNodesIpv6IspCityNode : allIpv6IspCityNodesNode)
+	{
+		Ipv6IspCityNode ipv6IspCityNodesObject;
+		if(!valueIpv6IspCityNodesIpv6IspCityNode["IspName"].isNull())
+			ipv6IspCityNodesObject.ispName = valueIpv6IspCityNodesIpv6IspCityNode["IspName"].asString();
+		if(!valueIpv6IspCityNodesIpv6IspCityNode["IspCode"].isNull())
+			ipv6IspCityNodesObject.ispCode = valueIpv6IspCityNodesIpv6IspCityNode["IspCode"].asString();
+		if(!valueIpv6IspCityNodesIpv6IspCityNode["CityName"].isNull())
+			ipv6IspCityNodesObject.cityName = valueIpv6IspCityNodesIpv6IspCityNode["CityName"].asString();
+		if(!valueIpv6IspCityNodesIpv6IspCityNode["CityCode"].isNull())
+			ipv6IspCityNodesObject.cityCode = valueIpv6IspCityNodesIpv6IspCityNode["CityCode"].asString();
+		if(!valueIpv6IspCityNodesIpv6IspCityNode["DefaultSelected"].isNull())
+			ipv6IspCityNodesObject.defaultSelected = valueIpv6IspCityNodesIpv6IspCityNode["DefaultSelected"].asString() == "true";
+		if(!valueIpv6IspCityNodesIpv6IspCityNode["GroupType"].isNull())
+			ipv6IspCityNodesObject.groupType = valueIpv6IspCityNodesIpv6IspCityNode["GroupType"].asString();
+		if(!valueIpv6IspCityNodesIpv6IspCityNode["GroupName"].isNull())
+			ipv6IspCityNodesObject.groupName = valueIpv6IspCityNodesIpv6IspCityNode["GroupName"].asString();
+		ipv6IspCityNodes_.push_back(ipv6IspCityNodesObject);
+	}
+	auto allDomainIpv4IspCityNodesNode = value["DomainIpv4IspCityNodes"]["DomainIpv4IspCityNode"];
+	for (auto valueDomainIpv4IspCityNodesDomainIpv4IspCityNode : allDomainIpv4IspCityNodesNode)
+	{
+		DomainIpv4IspCityNode domainIpv4IspCityNodesObject;
+		if(!valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["IspName"].isNull())
+			domainIpv4IspCityNodesObject.ispName = valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["IspName"].asString();
+		if(!valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["IspCode"].isNull())
+			domainIpv4IspCityNodesObject.ispCode = valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["IspCode"].asString();
+		if(!valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["CityName"].isNull())
+			domainIpv4IspCityNodesObject.cityName = valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["CityName"].asString();
+		if(!valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["CityCode"].isNull())
+			domainIpv4IspCityNodesObject.cityCode = valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["CityCode"].asString();
+		if(!valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["DefaultSelected"].isNull())
+			domainIpv4IspCityNodesObject.defaultSelected = valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["DefaultSelected"].asString() == "true";
+		if(!valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["GroupType"].isNull())
+			domainIpv4IspCityNodesObject.groupType = valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["GroupType"].asString();
+		if(!valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["GroupName"].isNull())
+			domainIpv4IspCityNodesObject.groupName = valueDomainIpv4IspCityNodesDomainIpv4IspCityNode["GroupName"].asString();
+		domainIpv4IspCityNodes_.push_back(domainIpv4IspCityNodesObject);
+	}
+	auto allDomainIpv6IspCityNodesNode = value["DomainIpv6IspCityNodes"]["DomainIpv6IspCityNode"];
+	for (auto valueDomainIpv6IspCityNodesDomainIpv6IspCityNode : allDomainIpv6IspCityNodesNode)
+	{
+		DomainIpv6IspCityNode domainIpv6IspCityNodesObject;
+		if(!valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["IspName"].isNull())
+			domainIpv6IspCityNodesObject.ispName = valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["IspName"].asString();
+		if(!valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["IspCode"].isNull())
+			domainIpv6IspCityNodesObject.ispCode = valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["IspCode"].asString();
+		if(!valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["CityName"].isNull())
+			domainIpv6IspCityNodesObject.cityName = valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["CityName"].asString();
+		if(!valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["CityCode"].isNull())
+			domainIpv6IspCityNodesObject.cityCode = valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["CityCode"].asString();
+		if(!valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["DefaultSelected"].isNull())
+			domainIpv6IspCityNodesObject.defaultSelected = valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["DefaultSelected"].asString() == "true";
+		if(!valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["GroupType"].isNull())
+			domainIpv6IspCityNodesObject.groupType = valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["GroupType"].asString();
+		if(!valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["GroupName"].isNull())
+			domainIpv6IspCityNodesObject.groupName = valueDomainIpv6IspCityNodesDomainIpv6IspCityNode["GroupName"].asString();
+		domainIpv6IspCityNodes_.push_back(domainIpv6IspCityNodesObject);
+	}
+
+}
+
+std::vector<DescribeDnsGtmMonitorAvailableConfigResult::Ipv4IspCityNode> DescribeDnsGtmMonitorAvailableConfigResult::getIpv4IspCityNodes()const
+{
+	return ipv4IspCityNodes_;
+}
+
+std::vector<DescribeDnsGtmMonitorAvailableConfigResult::DomainIpv4IspCityNode> DescribeDnsGtmMonitorAvailableConfigResult::getDomainIpv4IspCityNodes()const
+{
+	return domainIpv4IspCityNodes_;
+}
+
+std::vector<DescribeDnsGtmMonitorAvailableConfigResult::DomainIpv6IspCityNode> DescribeDnsGtmMonitorAvailableConfigResult::getDomainIpv6IspCityNodes()const
+{
+	return domainIpv6IspCityNodes_;
+}
+
+std::vector<DescribeDnsGtmMonitorAvailableConfigResult::Ipv6IspCityNode> DescribeDnsGtmMonitorAvailableConfigResult::getIpv6IspCityNodes()const
+{
+	return ipv6IspCityNodes_;
+}
+

alidns/src/model/DescribeDnsGtmMonitorConfigRequest.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/alidns/model/DescribeDnsGtmMonitorConfigRequest.h>
+
+using AlibabaCloud::Alidns::Model::DescribeDnsGtmMonitorConfigRequest;
+
+DescribeDnsGtmMonitorConfigRequest::DescribeDnsGtmMonitorConfigRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "DescribeDnsGtmMonitorConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDnsGtmMonitorConfigRequest::~DescribeDnsGtmMonitorConfigRequest()
+{}
+
+std::string DescribeDnsGtmMonitorConfigRequest::getMonitorConfigId()const
+{
+	return monitorConfigId_;
+}
+
+void DescribeDnsGtmMonitorConfigRequest::setMonitorConfigId(const std::string& monitorConfigId)
+{
+	monitorConfigId_ = monitorConfigId;
+	setParameter("MonitorConfigId", monitorConfigId);
+}
+
+std::string DescribeDnsGtmMonitorConfigRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void DescribeDnsGtmMonitorConfigRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string DescribeDnsGtmMonitorConfigRequest::getLang()const
+{
+	return lang_;
+}
+
+void DescribeDnsGtmMonitorConfigRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

alidns/src/model/DescribeDnsGtmMonitorConfigResult.cc

@@ -0,0 +1,137 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/DescribeDnsGtmMonitorConfigResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Alidns;
+using namespace AlibabaCloud::Alidns::Model;
+
+DescribeDnsGtmMonitorConfigResult::DescribeDnsGtmMonitorConfigResult() :
+	ServiceResult()
+{}
+
+DescribeDnsGtmMonitorConfigResult::DescribeDnsGtmMonitorConfigResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDnsGtmMonitorConfigResult::~DescribeDnsGtmMonitorConfigResult()
+{}
+
+void DescribeDnsGtmMonitorConfigResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allIspCityNodesNode = value["IspCityNodes"]["IspCityNode"];
+	for (auto valueIspCityNodesIspCityNode : allIspCityNodesNode)
+	{
+		IspCityNode ispCityNodesObject;
+		if(!valueIspCityNodesIspCityNode["CountryName"].isNull())
+			ispCityNodesObject.countryName = valueIspCityNodesIspCityNode["CountryName"].asString();
+		if(!valueIspCityNodesIspCityNode["CountryCode"].isNull())
+			ispCityNodesObject.countryCode = valueIspCityNodesIspCityNode["CountryCode"].asString();
+		if(!valueIspCityNodesIspCityNode["CityName"].isNull())
+			ispCityNodesObject.cityName = valueIspCityNodesIspCityNode["CityName"].asString();
+		if(!valueIspCityNodesIspCityNode["CityCode"].isNull())
+			ispCityNodesObject.cityCode = valueIspCityNodesIspCityNode["CityCode"].asString();
+		if(!valueIspCityNodesIspCityNode["IspCode"].isNull())
+			ispCityNodesObject.ispCode = valueIspCityNodesIspCityNode["IspCode"].asString();
+		if(!valueIspCityNodesIspCityNode["IspName"].isNull())
+			ispCityNodesObject.ispName = valueIspCityNodesIspCityNode["IspName"].asString();
+		ispCityNodes_.push_back(ispCityNodesObject);
+	}
+	if(!value["MonitorConfigId"].isNull())
+		monitorConfigId_ = value["MonitorConfigId"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["CreateTimestamp"].isNull())
+		createTimestamp_ = std::stol(value["CreateTimestamp"].asString());
+	if(!value["UpdateTime"].isNull())
+		updateTime_ = value["UpdateTime"].asString();
+	if(!value["UpdateTimestamp"].isNull())
+		updateTimestamp_ = std::stol(value["UpdateTimestamp"].asString());
+	if(!value["ProtocolType"].isNull())
+		protocolType_ = value["ProtocolType"].asString();
+	if(!value["Interval"].isNull())
+		interval_ = std::stoi(value["Interval"].asString());
+	if(!value["EvaluationCount"].isNull())
+		evaluationCount_ = std::stoi(value["EvaluationCount"].asString());
+	if(!value["Timeout"].isNull())
+		timeout_ = std::stoi(value["Timeout"].asString());
+	if(!value["MonitorExtendInfo"].isNull())
+		monitorExtendInfo_ = value["MonitorExtendInfo"].asString();
+
+}
+
+std::vector<DescribeDnsGtmMonitorConfigResult::IspCityNode> DescribeDnsGtmMonitorConfigResult::getIspCityNodes()const
+{
+	return ispCityNodes_;
+}
+
+std::string DescribeDnsGtmMonitorConfigResult::getProtocolType()const
+{
+	return protocolType_;
+}
+
+int DescribeDnsGtmMonitorConfigResult::getTimeout()const
+{
+	return timeout_;
+}
+
+std::string DescribeDnsGtmMonitorConfigResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+std::string DescribeDnsGtmMonitorConfigResult::getUpdateTime()const
+{
+	return updateTime_;
+}
+
+int DescribeDnsGtmMonitorConfigResult::getEvaluationCount()const
+{
+	return evaluationCount_;
+}
+
+long DescribeDnsGtmMonitorConfigResult::getUpdateTimestamp()const
+{
+	return updateTimestamp_;
+}
+
+std::string DescribeDnsGtmMonitorConfigResult::getMonitorExtendInfo()const
+{
+	return monitorExtendInfo_;
+}
+
+std::string DescribeDnsGtmMonitorConfigResult::getMonitorConfigId()const
+{
+	return monitorConfigId_;
+}
+
+long DescribeDnsGtmMonitorConfigResult::getCreateTimestamp()const
+{
+	return createTimestamp_;
+}
+
+int DescribeDnsGtmMonitorConfigResult::getInterval()const
+{
+	return interval_;
+}
+

alidns/src/model/DescribeDnsProductInstanceResult.cc

@@ -106,6 +106,8 @@ void DescribeDnsProductInstanceResult::parse(const std::string &payload)
 		dnsSecurity_ = value["DnsSecurity"].asString();
 	if(!value["PaymentType"].isNull())
 		paymentType_ = value["PaymentType"].asString();
+	if(!value["DomainType"].isNull())
+		domainType_ = value["DomainType"].asString();
 
 }
 
@@ -169,6 +171,11 @@ std::string DescribeDnsProductInstanceResult::getDnsSecurity()const
 	return dnsSecurity_;
 }
 
+std::string DescribeDnsProductInstanceResult::getDomainType()const
+{
+	return domainType_;
+}
+
 long DescribeDnsProductInstanceResult::getURLForwardCount()const
 {
 	return uRLForwardCount_;

alidns/src/model/DescribeDnsProductInstancesRequest.cc

@@ -49,6 +49,17 @@ void DescribeDnsProductInstancesRequest::setAccessKeyId(const std::string& acces
 	setParameter("AccessKeyId", accessKeyId);
 }
 
+std::string DescribeDnsProductInstancesRequest::getDomainType()const
+{
+	return domainType_;
+}
+
+void DescribeDnsProductInstancesRequest::setDomainType(const std::string& domainType)
+{
+	domainType_ = domainType;
+	setParameter("DomainType", domainType);
+}
+
 std::string DescribeDnsProductInstancesRequest::getUserClientIp()const
 {
 	return userClientIp_;

alidns/src/model/DescribeDnsProductInstancesResult.cc

@@ -115,6 +115,8 @@ void DescribeDnsProductInstancesResult::parse(const std::string &payload)
 		pageNumber_ = std::stol(value["PageNumber"].asString());
 	if(!value["PageSize"].isNull())
 		pageSize_ = std::stol(value["PageSize"].asString());
+	if(!value["DomainType"].isNull())
+		domainType_ = value["DomainType"].asString();
 
 }
 
@@ -123,6 +125,11 @@ long DescribeDnsProductInstancesResult::getTotalCount()const
 	return totalCount_;
 }
 
+std::string DescribeDnsProductInstancesResult::getDomainType()const
+{
+	return domainType_;
+}
+
 long DescribeDnsProductInstancesResult::getPageSize()const
 {
 	return pageSize_;

alidns/src/model/DescribeDomainInfoResult.cc

@@ -95,6 +95,8 @@ void DescribeDomainInfoResult::parse(const std::string &payload)
 		slaveDns_ = value["SlaveDns"].asString() == "true";
 	if(!value["ResourceGroupId"].isNull())
 		resourceGroupId_ = value["ResourceGroupId"].asString();
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
 
 }
 
@@ -143,6 +145,11 @@ std::string DescribeDomainInfoResult::getInstanceId()const
 	return instanceId_;
 }
 
+std::string DescribeDomainInfoResult::getCreateTime()const
+{
+	return createTime_;
+}
+
 std::string DescribeDomainInfoResult::getPunyCode()const
 {
 	return punyCode_;

alidns/src/model/DescribeDomainNsRequest.cc

@@ -49,6 +49,17 @@ void DescribeDomainNsRequest::setAccessKeyId(const std::string& accessKeyId)
 	setParameter("AccessKeyId", accessKeyId);
 }
 
+std::string DescribeDomainNsRequest::getDomainType()const
+{
+	return domainType_;
+}
+
+void DescribeDomainNsRequest::setDomainType(const std::string& domainType)
+{
+	domainType_ = domainType;
+	setParameter("DomainType", domainType);
+}
+
 std::string DescribeDomainNsRequest::getUserClientIp()const
 {
 	return userClientIp_;

alidns/src/model/DescribeDomainStatisticsRequest.cc

@@ -60,6 +60,17 @@ void DescribeDomainStatisticsRequest::setEndDate(const std::string& endDate)
 	setParameter("EndDate", endDate);
 }
 
+std::string DescribeDomainStatisticsRequest::getDomainType()const
+{
+	return domainType_;
+}
+
+void DescribeDomainStatisticsRequest::setDomainType(const std::string& domainType)
+{
+	domainType_ = domainType;
+	setParameter("DomainType", domainType);
+}
+
 std::string DescribeDomainStatisticsRequest::getUserClientIp()const
 {
 	return userClientIp_;

alidns/src/model/DescribeDomainStatisticsSummaryResult.cc

@@ -47,6 +47,8 @@ void DescribeDomainStatisticsSummaryResult::parse(const std::string &payload)
 			statisticsObject.domainName = valueStatisticsStatistic["DomainName"].asString();
 		if(!valueStatisticsStatistic["Count"].isNull())
 			statisticsObject.count = std::stol(valueStatisticsStatistic["Count"].asString());
+		if(!valueStatisticsStatistic["DomainType"].isNull())
+			statisticsObject.domainType = valueStatisticsStatistic["DomainType"].asString();
 		statistics_.push_back(statisticsObject);
 	}
 	if(!value["TotalItems"].isNull())

alidns/src/model/DescribeDomainsResult.cc

@@ -79,14 +79,14 @@ void DescribeDomainsResult::parse(const std::string &payload)
 			domainsObject.createTimestamp = std::stol(valueDomainsDomain["CreateTimestamp"].asString());
 		if(!valueDomainsDomain["ResourceGroupId"].isNull())
 			domainsObject.resourceGroupId = valueDomainsDomain["ResourceGroupId"].asString();
-		auto allTagsNode = allDomainsNode["Tags"]["Tag"];
-		for (auto allDomainsNodeTagsTag : allTagsNode)
+		auto allTagsNode = valueDomainsDomain["Tags"]["Tag"];
+		for (auto valueDomainsDomainTagsTag : allTagsNode)
 		{
 			Domain::Tag tagsObject;
-			if(!allDomainsNodeTagsTag["Key"].isNull())
-				tagsObject.key = allDomainsNodeTagsTag["Key"].asString();
-			if(!allDomainsNodeTagsTag["Value"].isNull())
-				tagsObject.value = allDomainsNodeTagsTag["Value"].asString();
+			if(!valueDomainsDomainTagsTag["Key"].isNull())
+				tagsObject.key = valueDomainsDomainTagsTag["Key"].asString();
+			if(!valueDomainsDomainTagsTag["Value"].isNull())
+				tagsObject.value = valueDomainsDomainTagsTag["Value"].asString();
 			domainsObject.tags.push_back(tagsObject);
 		}
 		auto allDnsServers = value["DnsServers"]["DnsServer"];

alidns/src/model/DescribeGtmAccessStrategiesResult.cc

@@ -75,18 +75,18 @@ void DescribeGtmAccessStrategiesResult::parse(const std::string &payload)
 			strategiesObject.defaultAddrPoolMonitorStatus = valueStrategiesStrategy["DefaultAddrPoolMonitorStatus"].asString();
 		if(!valueStrategiesStrategy["FailoverAddrPoolMonitorStatus"].isNull())
 			strategiesObject.failoverAddrPoolMonitorStatus = valueStrategiesStrategy["FailoverAddrPoolMonitorStatus"].asString();
-		auto allLinesNode = allStrategiesNode["Lines"]["Line"];
-		for (auto allStrategiesNodeLinesLine : allLinesNode)
+		auto allLinesNode = valueStrategiesStrategy["Lines"]["Line"];
+		for (auto valueStrategiesStrategyLinesLine : allLinesNode)
 		{
 			Strategy::Line linesObject;
-			if(!allStrategiesNodeLinesLine["LineCode"].isNull())
-				linesObject.lineCode = allStrategiesNodeLinesLine["LineCode"].asString();
-			if(!allStrategiesNodeLinesLine["LineName"].isNull())
-				linesObject.lineName = allStrategiesNodeLinesLine["LineName"].asString();
-			if(!allStrategiesNodeLinesLine["GroupCode"].isNull())
-				linesObject.groupCode = allStrategiesNodeLinesLine["GroupCode"].asString();
-			if(!allStrategiesNodeLinesLine["GroupName"].isNull())
-				linesObject.groupName = allStrategiesNodeLinesLine["GroupName"].asString();
+			if(!valueStrategiesStrategyLinesLine["LineCode"].isNull())
+				linesObject.lineCode = valueStrategiesStrategyLinesLine["LineCode"].asString();
+			if(!valueStrategiesStrategyLinesLine["LineName"].isNull())
+				linesObject.lineName = valueStrategiesStrategyLinesLine["LineName"].asString();
+			if(!valueStrategiesStrategyLinesLine["GroupCode"].isNull())
+				linesObject.groupCode = valueStrategiesStrategyLinesLine["GroupCode"].asString();
+			if(!valueStrategiesStrategyLinesLine["GroupName"].isNull())
+				linesObject.groupName = valueStrategiesStrategyLinesLine["GroupName"].asString();
 			strategiesObject.lines.push_back(linesObject);
 		}
 		strategies_.push_back(strategiesObject);

alidns/src/model/DescribeGtmRecoveryPlanAvailableConfigResult.cc

@@ -47,14 +47,14 @@ void DescribeGtmRecoveryPlanAvailableConfigResult::parse(const std::string &payl
 			instancesObject.instanceId = valueInstancesInstance["InstanceId"].asString();
 		if(!valueInstancesInstance["InstanceName"].isNull())
 			instancesObject.instanceName = valueInstancesInstance["InstanceName"].asString();
-		auto allAddrPoolsNode = allInstancesNode["AddrPools"]["AddrPool"];
-		for (auto allInstancesNodeAddrPoolsAddrPool : allAddrPoolsNode)
+		auto allAddrPoolsNode = valueInstancesInstance["AddrPools"]["AddrPool"];
+		for (auto valueInstancesInstanceAddrPoolsAddrPool : allAddrPoolsNode)
 		{
 			Instance::AddrPool addrPoolsObject;
-			if(!allInstancesNodeAddrPoolsAddrPool["AddrPoolId"].isNull())
-				addrPoolsObject.addrPoolId = allInstancesNodeAddrPoolsAddrPool["AddrPoolId"].asString();
-			if(!allInstancesNodeAddrPoolsAddrPool["Name"].isNull())
-				addrPoolsObject.name = allInstancesNodeAddrPoolsAddrPool["Name"].asString();
+			if(!valueInstancesInstanceAddrPoolsAddrPool["AddrPoolId"].isNull())
+				addrPoolsObject.addrPoolId = valueInstancesInstanceAddrPoolsAddrPool["AddrPoolId"].asString();
+			if(!valueInstancesInstanceAddrPoolsAddrPool["Name"].isNull())
+				addrPoolsObject.name = valueInstancesInstanceAddrPoolsAddrPool["Name"].asString();
 			instancesObject.addrPools.push_back(addrPoolsObject);
 		}
 		instances_.push_back(instancesObject);

alidns/src/model/DescribeGtmRecoveryPlanResult.cc

@@ -49,16 +49,16 @@ void DescribeGtmRecoveryPlanResult::parse(const std::string &payload)
 			faultAddrPoolsObject.addrPoolName = valueFaultAddrPoolsFaultAddrPool["AddrPoolName"].asString();
 		if(!valueFaultAddrPoolsFaultAddrPool["InstanceId"].isNull())
 			faultAddrPoolsObject.instanceId = valueFaultAddrPoolsFaultAddrPool["InstanceId"].asString();
-		auto allAddrsNode = allFaultAddrPoolsNode["Addrs"]["Addr"];
-		for (auto allFaultAddrPoolsNodeAddrsAddr : allAddrsNode)
+		auto allAddrsNode = valueFaultAddrPoolsFaultAddrPool["Addrs"]["Addr"];
+		for (auto valueFaultAddrPoolsFaultAddrPoolAddrsAddr : allAddrsNode)
 		{
 			FaultAddrPool::Addr addrsObject;
-			if(!allFaultAddrPoolsNodeAddrsAddr["Id"].isNull())
-				addrsObject.id = std::stol(allFaultAddrPoolsNodeAddrsAddr["Id"].asString());
-			if(!allFaultAddrPoolsNodeAddrsAddr["Mode"].isNull())
-				addrsObject.mode = allFaultAddrPoolsNodeAddrsAddr["Mode"].asString();
-			if(!allFaultAddrPoolsNodeAddrsAddr["Value"].isNull())
-				addrsObject.value = allFaultAddrPoolsNodeAddrsAddr["Value"].asString();
+			if(!valueFaultAddrPoolsFaultAddrPoolAddrsAddr["Id"].isNull())
+				addrsObject.id = std::stol(valueFaultAddrPoolsFaultAddrPoolAddrsAddr["Id"].asString());
+			if(!valueFaultAddrPoolsFaultAddrPoolAddrsAddr["Mode"].isNull())
+				addrsObject.mode = valueFaultAddrPoolsFaultAddrPoolAddrsAddr["Mode"].asString();
+			if(!valueFaultAddrPoolsFaultAddrPoolAddrsAddr["Value"].isNull())
+				addrsObject.value = valueFaultAddrPoolsFaultAddrPoolAddrsAddr["Value"].asString();
 			faultAddrPoolsObject.addrs.push_back(addrsObject);
 		}
 		faultAddrPools_.push_back(faultAddrPoolsObject);

alidns/src/model/DescribeRecordStatisticsRequest.cc

@@ -71,6 +71,17 @@ void DescribeRecordStatisticsRequest::setEndDate(const std::string& endDate)
 	setParameter("EndDate", endDate);
 }
 
+std::string DescribeRecordStatisticsRequest::getDomainType()const
+{
+	return domainType_;
+}
+
+void DescribeRecordStatisticsRequest::setDomainType(const std::string& domainType)
+{
+	domainType_ = domainType;
+	setParameter("DomainType", domainType);
+}
+
 std::string DescribeRecordStatisticsRequest::getUserClientIp()const
 {
 	return userClientIp_;

alidns/src/model/DescribeRecordStatisticsSummaryRequest.cc

@@ -60,6 +60,17 @@ void DescribeRecordStatisticsSummaryRequest::setPageNumber(long pageNumber)
 	setParameter("PageNumber", std::to_string(pageNumber));
 }
 
+std::string DescribeRecordStatisticsSummaryRequest::getDomainType()const
+{
+	return domainType_;
+}
+
+void DescribeRecordStatisticsSummaryRequest::setDomainType(const std::string& domainType)
+{
+	domainType_ = domainType;
+	setParameter("DomainType", domainType);
+}
+
 long DescribeRecordStatisticsSummaryRequest::getPageSize()const
 {
 	return pageSize_;

alidns/src/model/MoveDomainResourceGroupRequest.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/alidns/model/MoveDomainResourceGroupRequest.h>
+
+using AlibabaCloud::Alidns::Model::MoveDomainResourceGroupRequest;
+
+MoveDomainResourceGroupRequest::MoveDomainResourceGroupRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "MoveDomainResourceGroup")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+MoveDomainResourceGroupRequest::~MoveDomainResourceGroupRequest()
+{}
+
+std::string MoveDomainResourceGroupRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void MoveDomainResourceGroupRequest::setResourceId(const std::string& resourceId)
+{
+	resourceId_ = resourceId;
+	setParameter("ResourceId", resourceId);
+}
+
+std::string MoveDomainResourceGroupRequest::getNewResourceGroupId()const
+{
+	return newResourceGroupId_;
+}
+
+void MoveDomainResourceGroupRequest::setNewResourceGroupId(const std::string& newResourceGroupId)
+{
+	newResourceGroupId_ = newResourceGroupId;
+	setParameter("NewResourceGroupId", newResourceGroupId);
+}
+
+std::string MoveDomainResourceGroupRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void MoveDomainResourceGroupRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string MoveDomainResourceGroupRequest::getLang()const
+{
+	return lang_;
+}
+
+void MoveDomainResourceGroupRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

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

alidns/src/model/MoveGtmResourceGroupRequest.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/alidns/model/MoveGtmResourceGroupRequest.h>
+
+using AlibabaCloud::Alidns::Model::MoveGtmResourceGroupRequest;
+
+MoveGtmResourceGroupRequest::MoveGtmResourceGroupRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "MoveGtmResourceGroup")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+MoveGtmResourceGroupRequest::~MoveGtmResourceGroupRequest()
+{}
+
+std::string MoveGtmResourceGroupRequest::getResourceId()const
+{
+	return resourceId_;
+}
+
+void MoveGtmResourceGroupRequest::setResourceId(const std::string& resourceId)
+{
+	resourceId_ = resourceId;
+	setParameter("ResourceId", resourceId);
+}
+
+std::string MoveGtmResourceGroupRequest::getNewResourceGroupId()const
+{
+	return newResourceGroupId_;
+}
+
+void MoveGtmResourceGroupRequest::setNewResourceGroupId(const std::string& newResourceGroupId)
+{
+	newResourceGroupId_ = newResourceGroupId;
+	setParameter("NewResourceGroupId", newResourceGroupId);
+}
+
+std::string MoveGtmResourceGroupRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void MoveGtmResourceGroupRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string MoveGtmResourceGroupRequest::getLang()const
+{
+	return lang_;
+}
+
+void MoveGtmResourceGroupRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

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

alidns/src/model/PreviewGtmRecoveryPlanResult.cc

@@ -49,14 +49,14 @@ void PreviewGtmRecoveryPlanResult::parse(const std::string &payload)
 			previewsObject.name = valuePreviewsPreview["Name"].asString();
 		if(!valuePreviewsPreview["UserDomainName"].isNull())
 			previewsObject.userDomainName = valuePreviewsPreview["UserDomainName"].asString();
-		auto allSwitchInfosNode = allPreviewsNode["SwitchInfos"]["SwitchInfo"];
-		for (auto allPreviewsNodeSwitchInfosSwitchInfo : allSwitchInfosNode)
+		auto allSwitchInfosNode = valuePreviewsPreview["SwitchInfos"]["SwitchInfo"];
+		for (auto valuePreviewsPreviewSwitchInfosSwitchInfo : allSwitchInfosNode)
 		{
 			Preview::SwitchInfo switchInfosObject;
-			if(!allPreviewsNodeSwitchInfosSwitchInfo["StrategyName"].isNull())
-				switchInfosObject.strategyName = allPreviewsNodeSwitchInfosSwitchInfo["StrategyName"].asString();
-			if(!allPreviewsNodeSwitchInfosSwitchInfo["Content"].isNull())
-				switchInfosObject.content = allPreviewsNodeSwitchInfosSwitchInfo["Content"].asString();
+			if(!valuePreviewsPreviewSwitchInfosSwitchInfo["StrategyName"].isNull())
+				switchInfosObject.strategyName = valuePreviewsPreviewSwitchInfosSwitchInfo["StrategyName"].asString();
+			if(!valuePreviewsPreviewSwitchInfosSwitchInfo["Content"].isNull())
+				switchInfosObject.content = valuePreviewsPreviewSwitchInfosSwitchInfo["Content"].asString();
 			previewsObject.switchInfos.push_back(switchInfosObject);
 		}
 		previews_.push_back(previewsObject);

alidns/src/model/SetDnsGtmAccessModeRequest.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/alidns/model/SetDnsGtmAccessModeRequest.h>
+
+using AlibabaCloud::Alidns::Model::SetDnsGtmAccessModeRequest;
+
+SetDnsGtmAccessModeRequest::SetDnsGtmAccessModeRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "SetDnsGtmAccessMode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SetDnsGtmAccessModeRequest::~SetDnsGtmAccessModeRequest()
+{}
+
+std::string SetDnsGtmAccessModeRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void SetDnsGtmAccessModeRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string SetDnsGtmAccessModeRequest::getStrategyId()const
+{
+	return strategyId_;
+}
+
+void SetDnsGtmAccessModeRequest::setStrategyId(const std::string& strategyId)
+{
+	strategyId_ = strategyId;
+	setParameter("StrategyId", strategyId);
+}
+
+std::string SetDnsGtmAccessModeRequest::getLang()const
+{
+	return lang_;
+}
+
+void SetDnsGtmAccessModeRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::string SetDnsGtmAccessModeRequest::getAccessMode()const
+{
+	return accessMode_;
+}
+
+void SetDnsGtmAccessModeRequest::setAccessMode(const std::string& accessMode)
+{
+	accessMode_ = accessMode;
+	setParameter("AccessMode", accessMode);
+}
+

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

alidns/src/model/SetDnsGtmMonitorStatusRequest.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/alidns/model/SetDnsGtmMonitorStatusRequest.h>
+
+using AlibabaCloud::Alidns::Model::SetDnsGtmMonitorStatusRequest;
+
+SetDnsGtmMonitorStatusRequest::SetDnsGtmMonitorStatusRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "SetDnsGtmMonitorStatus")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SetDnsGtmMonitorStatusRequest::~SetDnsGtmMonitorStatusRequest()
+{}
+
+std::string SetDnsGtmMonitorStatusRequest::getMonitorConfigId()const
+{
+	return monitorConfigId_;
+}
+
+void SetDnsGtmMonitorStatusRequest::setMonitorConfigId(const std::string& monitorConfigId)
+{
+	monitorConfigId_ = monitorConfigId;
+	setParameter("MonitorConfigId", monitorConfigId);
+}
+
+std::string SetDnsGtmMonitorStatusRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void SetDnsGtmMonitorStatusRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string SetDnsGtmMonitorStatusRequest::getLang()const
+{
+	return lang_;
+}
+
+void SetDnsGtmMonitorStatusRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::string SetDnsGtmMonitorStatusRequest::getStatus()const
+{
+	return status_;
+}
+
+void SetDnsGtmMonitorStatusRequest::setStatus(const std::string& status)
+{
+	status_ = status;
+	setParameter("Status", status);
+}
+

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

alidns/src/model/SwitchDnsGtmInstanceStrategyModeRequest.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/alidns/model/SwitchDnsGtmInstanceStrategyModeRequest.h>
+
+using AlibabaCloud::Alidns::Model::SwitchDnsGtmInstanceStrategyModeRequest;
+
+SwitchDnsGtmInstanceStrategyModeRequest::SwitchDnsGtmInstanceStrategyModeRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "SwitchDnsGtmInstanceStrategyMode")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+SwitchDnsGtmInstanceStrategyModeRequest::~SwitchDnsGtmInstanceStrategyModeRequest()
+{}
+
+std::string SwitchDnsGtmInstanceStrategyModeRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void SwitchDnsGtmInstanceStrategyModeRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string SwitchDnsGtmInstanceStrategyModeRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void SwitchDnsGtmInstanceStrategyModeRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string SwitchDnsGtmInstanceStrategyModeRequest::getStrategyMode()const
+{
+	return strategyMode_;
+}
+
+void SwitchDnsGtmInstanceStrategyModeRequest::setStrategyMode(const std::string& strategyMode)
+{
+	strategyMode_ = strategyMode;
+	setParameter("StrategyMode", strategyMode);
+}
+
+std::string SwitchDnsGtmInstanceStrategyModeRequest::getLang()const
+{
+	return lang_;
+}
+
+void SwitchDnsGtmInstanceStrategyModeRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+

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

alidns/src/model/UpdateDnsGtmAccessStrategyRequest.cc

@@ -0,0 +1,226 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/UpdateDnsGtmAccessStrategyRequest.h>
+
+using AlibabaCloud::Alidns::Model::UpdateDnsGtmAccessStrategyRequest;
+
+UpdateDnsGtmAccessStrategyRequest::UpdateDnsGtmAccessStrategyRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "UpdateDnsGtmAccessStrategy")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateDnsGtmAccessStrategyRequest::~UpdateDnsGtmAccessStrategyRequest()
+{}
+
+std::string UpdateDnsGtmAccessStrategyRequest::getDefaultLbaStrategy()const
+{
+	return defaultLbaStrategy_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setDefaultLbaStrategy(const std::string& defaultLbaStrategy)
+{
+	defaultLbaStrategy_ = defaultLbaStrategy;
+	setParameter("DefaultLbaStrategy", defaultLbaStrategy);
+}
+
+std::string UpdateDnsGtmAccessStrategyRequest::getFailoverAddrPoolType()const
+{
+	return failoverAddrPoolType_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setFailoverAddrPoolType(const std::string& failoverAddrPoolType)
+{
+	failoverAddrPoolType_ = failoverAddrPoolType;
+	setParameter("FailoverAddrPoolType", failoverAddrPoolType);
+}
+
+std::string UpdateDnsGtmAccessStrategyRequest::getDefaultAddrPoolType()const
+{
+	return defaultAddrPoolType_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setDefaultAddrPoolType(const std::string& defaultAddrPoolType)
+{
+	defaultAddrPoolType_ = defaultAddrPoolType;
+	setParameter("DefaultAddrPoolType", defaultAddrPoolType);
+}
+
+int UpdateDnsGtmAccessStrategyRequest::getFailoverMaxReturnAddrNum()const
+{
+	return failoverMaxReturnAddrNum_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setFailoverMaxReturnAddrNum(int failoverMaxReturnAddrNum)
+{
+	failoverMaxReturnAddrNum_ = failoverMaxReturnAddrNum;
+	setParameter("FailoverMaxReturnAddrNum", std::to_string(failoverMaxReturnAddrNum));
+}
+
+std::string UpdateDnsGtmAccessStrategyRequest::getFailoverLbaStrategy()const
+{
+	return failoverLbaStrategy_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setFailoverLbaStrategy(const std::string& failoverLbaStrategy)
+{
+	failoverLbaStrategy_ = failoverLbaStrategy;
+	setParameter("FailoverLbaStrategy", failoverLbaStrategy);
+}
+
+std::vector<UpdateDnsGtmAccessStrategyRequest::DefaultAddrPool> UpdateDnsGtmAccessStrategyRequest::getDefaultAddrPool()const
+{
+	return defaultAddrPool_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setDefaultAddrPool(const std::vector<DefaultAddrPool>& defaultAddrPool)
+{
+	defaultAddrPool_ = defaultAddrPool;
+	for(int dep1 = 0; dep1!= defaultAddrPool.size(); dep1++) {
+		auto defaultAddrPoolObj = defaultAddrPool.at(dep1);
+		std::string defaultAddrPoolObjStr = "DefaultAddrPool." + std::to_string(dep1 + 1);
+		setParameter(defaultAddrPoolObjStr + ".Id", defaultAddrPoolObj.id);
+		setParameter(defaultAddrPoolObjStr + ".LbaWeight", std::to_string(defaultAddrPoolObj.lbaWeight));
+	}
+}
+
+int UpdateDnsGtmAccessStrategyRequest::getFailoverMinAvailableAddrNum()const
+{
+	return failoverMinAvailableAddrNum_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setFailoverMinAvailableAddrNum(int failoverMinAvailableAddrNum)
+{
+	failoverMinAvailableAddrNum_ = failoverMinAvailableAddrNum;
+	setParameter("FailoverMinAvailableAddrNum", std::to_string(failoverMinAvailableAddrNum));
+}
+
+int UpdateDnsGtmAccessStrategyRequest::getDefaultMaxReturnAddrNum()const
+{
+	return defaultMaxReturnAddrNum_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setDefaultMaxReturnAddrNum(int defaultMaxReturnAddrNum)
+{
+	defaultMaxReturnAddrNum_ = defaultMaxReturnAddrNum;
+	setParameter("DefaultMaxReturnAddrNum", std::to_string(defaultMaxReturnAddrNum));
+}
+
+int UpdateDnsGtmAccessStrategyRequest::getDefaultMinAvailableAddrNum()const
+{
+	return defaultMinAvailableAddrNum_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setDefaultMinAvailableAddrNum(int defaultMinAvailableAddrNum)
+{
+	defaultMinAvailableAddrNum_ = defaultMinAvailableAddrNum;
+	setParameter("DefaultMinAvailableAddrNum", std::to_string(defaultMinAvailableAddrNum));
+}
+
+std::string UpdateDnsGtmAccessStrategyRequest::getLang()const
+{
+	return lang_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::string UpdateDnsGtmAccessStrategyRequest::getLines()const
+{
+	return lines_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setLines(const std::string& lines)
+{
+	lines_ = lines;
+	setParameter("Lines", lines);
+}
+
+std::string UpdateDnsGtmAccessStrategyRequest::getStrategyName()const
+{
+	return strategyName_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setStrategyName(const std::string& strategyName)
+{
+	strategyName_ = strategyName;
+	setParameter("StrategyName", strategyName);
+}
+
+std::string UpdateDnsGtmAccessStrategyRequest::getDefaultLatencyOptimization()const
+{
+	return defaultLatencyOptimization_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setDefaultLatencyOptimization(const std::string& defaultLatencyOptimization)
+{
+	defaultLatencyOptimization_ = defaultLatencyOptimization;
+	setParameter("DefaultLatencyOptimization", defaultLatencyOptimization);
+}
+
+std::string UpdateDnsGtmAccessStrategyRequest::getFailoverLatencyOptimization()const
+{
+	return failoverLatencyOptimization_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setFailoverLatencyOptimization(const std::string& failoverLatencyOptimization)
+{
+	failoverLatencyOptimization_ = failoverLatencyOptimization;
+	setParameter("FailoverLatencyOptimization", failoverLatencyOptimization);
+}
+
+std::string UpdateDnsGtmAccessStrategyRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string UpdateDnsGtmAccessStrategyRequest::getStrategyId()const
+{
+	return strategyId_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setStrategyId(const std::string& strategyId)
+{
+	strategyId_ = strategyId;
+	setParameter("StrategyId", strategyId);
+}
+
+std::vector<UpdateDnsGtmAccessStrategyRequest::FailoverAddrPool> UpdateDnsGtmAccessStrategyRequest::getFailoverAddrPool()const
+{
+	return failoverAddrPool_;
+}
+
+void UpdateDnsGtmAccessStrategyRequest::setFailoverAddrPool(const std::vector<FailoverAddrPool>& failoverAddrPool)
+{
+	failoverAddrPool_ = failoverAddrPool;
+	for(int dep1 = 0; dep1!= failoverAddrPool.size(); dep1++) {
+		auto failoverAddrPoolObj = failoverAddrPool.at(dep1);
+		std::string failoverAddrPoolObjStr = "FailoverAddrPool." + std::to_string(dep1 + 1);
+		setParameter(failoverAddrPoolObjStr + ".Id", failoverAddrPoolObj.id);
+		setParameter(failoverAddrPoolObjStr + ".LbaWeight", std::to_string(failoverAddrPoolObj.lbaWeight));
+	}
+}
+

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

alidns/src/model/UpdateDnsGtmAddressPoolRequest.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/alidns/model/UpdateDnsGtmAddressPoolRequest.h>
+
+using AlibabaCloud::Alidns::Model::UpdateDnsGtmAddressPoolRequest;
+
+UpdateDnsGtmAddressPoolRequest::UpdateDnsGtmAddressPoolRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "UpdateDnsGtmAddressPool")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateDnsGtmAddressPoolRequest::~UpdateDnsGtmAddressPoolRequest()
+{}
+
+std::string UpdateDnsGtmAddressPoolRequest::getLbaStrategy()const
+{
+	return lbaStrategy_;
+}
+
+void UpdateDnsGtmAddressPoolRequest::setLbaStrategy(const std::string& lbaStrategy)
+{
+	lbaStrategy_ = lbaStrategy;
+	setParameter("LbaStrategy", lbaStrategy);
+}
+
+std::string UpdateDnsGtmAddressPoolRequest::getAddrPoolId()const
+{
+	return addrPoolId_;
+}
+
+void UpdateDnsGtmAddressPoolRequest::setAddrPoolId(const std::string& addrPoolId)
+{
+	addrPoolId_ = addrPoolId;
+	setParameter("AddrPoolId", addrPoolId);
+}
+
+std::string UpdateDnsGtmAddressPoolRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void UpdateDnsGtmAddressPoolRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string UpdateDnsGtmAddressPoolRequest::getName()const
+{
+	return name_;
+}
+
+void UpdateDnsGtmAddressPoolRequest::setName(const std::string& name)
+{
+	name_ = name;
+	setParameter("Name", name);
+}
+
+std::string UpdateDnsGtmAddressPoolRequest::getLang()const
+{
+	return lang_;
+}
+
+void UpdateDnsGtmAddressPoolRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::vector<UpdateDnsGtmAddressPoolRequest::Addr> UpdateDnsGtmAddressPoolRequest::getAddr()const
+{
+	return addr_;
+}
+
+void UpdateDnsGtmAddressPoolRequest::setAddr(const std::vector<Addr>& addr)
+{
+	addr_ = addr;
+	for(int dep1 = 0; dep1!= addr.size(); dep1++) {
+		auto addrObj = addr.at(dep1);
+		std::string addrObjStr = "Addr." + std::to_string(dep1 + 1);
+		setParameter(addrObjStr + ".Mode", addrObj.mode);
+		setParameter(addrObjStr + ".AttributeInfo", addrObj.attributeInfo);
+		setParameter(addrObjStr + ".Remark", addrObj.remark);
+		setParameter(addrObjStr + ".Addr", addrObj.addr);
+		setParameter(addrObjStr + ".LbaWeight", std::to_string(addrObj.lbaWeight));
+	}
+}
+

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

alidns/src/model/UpdateDnsGtmInstanceGlobalConfigRequest.cc

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/UpdateDnsGtmInstanceGlobalConfigRequest.h>
+
+using AlibabaCloud::Alidns::Model::UpdateDnsGtmInstanceGlobalConfigRequest;
+
+UpdateDnsGtmInstanceGlobalConfigRequest::UpdateDnsGtmInstanceGlobalConfigRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "UpdateDnsGtmInstanceGlobalConfig")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateDnsGtmInstanceGlobalConfigRequest::~UpdateDnsGtmInstanceGlobalConfigRequest()
+{}
+
+std::string UpdateDnsGtmInstanceGlobalConfigRequest::getAlertGroup()const
+{
+	return alertGroup_;
+}
+
+void UpdateDnsGtmInstanceGlobalConfigRequest::setAlertGroup(const std::string& alertGroup)
+{
+	alertGroup_ = alertGroup;
+	setParameter("AlertGroup", alertGroup);
+}
+
+std::string UpdateDnsGtmInstanceGlobalConfigRequest::getCnameType()const
+{
+	return cnameType_;
+}
+
+void UpdateDnsGtmInstanceGlobalConfigRequest::setCnameType(const std::string& cnameType)
+{
+	cnameType_ = cnameType;
+	setParameter("CnameType", cnameType);
+}
+
+std::string UpdateDnsGtmInstanceGlobalConfigRequest::getLang()const
+{
+	return lang_;
+}
+
+void UpdateDnsGtmInstanceGlobalConfigRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::vector<UpdateDnsGtmInstanceGlobalConfigRequest::AlertConfig> UpdateDnsGtmInstanceGlobalConfigRequest::getAlertConfig()const
+{
+	return alertConfig_;
+}
+
+void UpdateDnsGtmInstanceGlobalConfigRequest::setAlertConfig(const std::vector<AlertConfig>& alertConfig)
+{
+	alertConfig_ = alertConfig;
+	for(int dep1 = 0; dep1!= alertConfig.size(); dep1++) {
+		auto alertConfigObj = alertConfig.at(dep1);
+		std::string alertConfigObjStr = "AlertConfig." + std::to_string(dep1 + 1);
+		setParameter(alertConfigObjStr + ".SmsNotice", alertConfigObj.smsNotice ? "true" : "false");
+		setParameter(alertConfigObjStr + ".NoticeType", alertConfigObj.noticeType);
+		setParameter(alertConfigObjStr + ".EmailNotice", alertConfigObj.emailNotice ? "true" : "false");
+	}
+}
+
+std::string UpdateDnsGtmInstanceGlobalConfigRequest::getPublicCnameMode()const
+{
+	return publicCnameMode_;
+}
+
+void UpdateDnsGtmInstanceGlobalConfigRequest::setPublicCnameMode(const std::string& publicCnameMode)
+{
+	publicCnameMode_ = publicCnameMode;
+	setParameter("PublicCnameMode", publicCnameMode);
+}
+
+std::string UpdateDnsGtmInstanceGlobalConfigRequest::getPublicUserDomainName()const
+{
+	return publicUserDomainName_;
+}
+
+void UpdateDnsGtmInstanceGlobalConfigRequest::setPublicUserDomainName(const std::string& publicUserDomainName)
+{
+	publicUserDomainName_ = publicUserDomainName;
+	setParameter("PublicUserDomainName", publicUserDomainName);
+}
+
+int UpdateDnsGtmInstanceGlobalConfigRequest::getTtl()const
+{
+	return ttl_;
+}
+
+void UpdateDnsGtmInstanceGlobalConfigRequest::setTtl(int ttl)
+{
+	ttl_ = ttl;
+	setParameter("Ttl", std::to_string(ttl));
+}
+
+std::string UpdateDnsGtmInstanceGlobalConfigRequest::getInstanceId()const
+{
+	return instanceId_;
+}
+
+void UpdateDnsGtmInstanceGlobalConfigRequest::setInstanceId(const std::string& instanceId)
+{
+	instanceId_ = instanceId;
+	setParameter("InstanceId", instanceId);
+}
+
+std::string UpdateDnsGtmInstanceGlobalConfigRequest::getInstanceName()const
+{
+	return instanceName_;
+}
+
+void UpdateDnsGtmInstanceGlobalConfigRequest::setInstanceName(const std::string& instanceName)
+{
+	instanceName_ = instanceName;
+	setParameter("InstanceName", instanceName);
+}
+
+std::string UpdateDnsGtmInstanceGlobalConfigRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void UpdateDnsGtmInstanceGlobalConfigRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+std::string UpdateDnsGtmInstanceGlobalConfigRequest::getPublicZoneName()const
+{
+	return publicZoneName_;
+}
+
+void UpdateDnsGtmInstanceGlobalConfigRequest::setPublicZoneName(const std::string& publicZoneName)
+{
+	publicZoneName_ = publicZoneName;
+	setParameter("PublicZoneName", publicZoneName);
+}
+

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

alidns/src/model/UpdateDnsGtmMonitorRequest.cc

@@ -0,0 +1,133 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/alidns/model/UpdateDnsGtmMonitorRequest.h>
+
+using AlibabaCloud::Alidns::Model::UpdateDnsGtmMonitorRequest;
+
+UpdateDnsGtmMonitorRequest::UpdateDnsGtmMonitorRequest() :
+	RpcServiceRequest("alidns", "2015-01-09", "UpdateDnsGtmMonitor")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+UpdateDnsGtmMonitorRequest::~UpdateDnsGtmMonitorRequest()
+{}
+
+std::string UpdateDnsGtmMonitorRequest::getMonitorExtendInfo()const
+{
+	return monitorExtendInfo_;
+}
+
+void UpdateDnsGtmMonitorRequest::setMonitorExtendInfo(const std::string& monitorExtendInfo)
+{
+	monitorExtendInfo_ = monitorExtendInfo;
+	setParameter("MonitorExtendInfo", monitorExtendInfo);
+}
+
+std::string UpdateDnsGtmMonitorRequest::getMonitorConfigId()const
+{
+	return monitorConfigId_;
+}
+
+void UpdateDnsGtmMonitorRequest::setMonitorConfigId(const std::string& monitorConfigId)
+{
+	monitorConfigId_ = monitorConfigId;
+	setParameter("MonitorConfigId", monitorConfigId);
+}
+
+int UpdateDnsGtmMonitorRequest::getTimeout()const
+{
+	return timeout_;
+}
+
+void UpdateDnsGtmMonitorRequest::setTimeout(int timeout)
+{
+	timeout_ = timeout;
+	setParameter("Timeout", std::to_string(timeout));
+}
+
+std::string UpdateDnsGtmMonitorRequest::getUserClientIp()const
+{
+	return userClientIp_;
+}
+
+void UpdateDnsGtmMonitorRequest::setUserClientIp(const std::string& userClientIp)
+{
+	userClientIp_ = userClientIp;
+	setParameter("UserClientIp", userClientIp);
+}
+
+int UpdateDnsGtmMonitorRequest::getEvaluationCount()const
+{
+	return evaluationCount_;
+}
+
+void UpdateDnsGtmMonitorRequest::setEvaluationCount(int evaluationCount)
+{
+	evaluationCount_ = evaluationCount;
+	setParameter("EvaluationCount", std::to_string(evaluationCount));
+}
+
+std::string UpdateDnsGtmMonitorRequest::getProtocolType()const
+{
+	return protocolType_;
+}
+
+void UpdateDnsGtmMonitorRequest::setProtocolType(const std::string& protocolType)
+{
+	protocolType_ = protocolType;
+	setParameter("ProtocolType", protocolType);
+}
+
+int UpdateDnsGtmMonitorRequest::getInterval()const
+{
+	return interval_;
+}
+
+void UpdateDnsGtmMonitorRequest::setInterval(int interval)
+{
+	interval_ = interval;
+	setParameter("Interval", std::to_string(interval));
+}
+
+std::string UpdateDnsGtmMonitorRequest::getLang()const
+{
+	return lang_;
+}
+
+void UpdateDnsGtmMonitorRequest::setLang(const std::string& lang)
+{
+	lang_ = lang;
+	setParameter("Lang", lang);
+}
+
+std::vector<UpdateDnsGtmMonitorRequest::IspCityNode> UpdateDnsGtmMonitorRequest::getIspCityNode()const
+{
+	return ispCityNode_;
+}
+
+void UpdateDnsGtmMonitorRequest::setIspCityNode(const std::vector<IspCityNode>& ispCityNode)
+{
+	ispCityNode_ = ispCityNode;
+	for(int dep1 = 0; dep1!= ispCityNode.size(); dep1++) {
+		auto ispCityNodeObj = ispCityNode.at(dep1);
+		std::string ispCityNodeObjStr = "IspCityNode." + std::to_string(dep1 + 1);
+		setParameter(ispCityNodeObjStr + ".CityCode", ispCityNodeObj.cityCode);
+		setParameter(ispCityNodeObjStr + ".IspCode", ispCityNodeObj.ispCode);
+	}
+}
+

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