Publish Api：GetNisNetworkRanking

VERSION

@@ -1 +1 @@
-1.36.1947
+1.36.1948

nis/CMakeLists.txt

@@ -0,0 +1,130 @@
+#
+# Copyright 2009-2017 Alibaba Cloud All rights reserved.
+# 
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#      http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+set(public_header_dir ${CMAKE_CURRENT_SOURCE_DIR}/../include)
+
+set(nis_public_header 
+	include/alibabacloud/nis/NisClient.h
+	include/alibabacloud/nis/NisExport.h )
+
+set(nis_public_header_model 
+	include/alibabacloud/nis/model/CreateAndAnalyzeNetworkPathRequest.h
+	include/alibabacloud/nis/model/CreateAndAnalyzeNetworkPathResult.h
+	include/alibabacloud/nis/model/CreateNetworkPathRequest.h
+	include/alibabacloud/nis/model/CreateNetworkPathResult.h
+	include/alibabacloud/nis/model/CreateNetworkReachableAnalysisRequest.h
+	include/alibabacloud/nis/model/CreateNetworkReachableAnalysisResult.h
+	include/alibabacloud/nis/model/DeleteNetworkPathRequest.h
+	include/alibabacloud/nis/model/DeleteNetworkPathResult.h
+	include/alibabacloud/nis/model/DeleteNetworkReachableAnalysisRequest.h
+	include/alibabacloud/nis/model/DeleteNetworkReachableAnalysisResult.h
+	include/alibabacloud/nis/model/GetInternetTupleRequest.h
+	include/alibabacloud/nis/model/GetInternetTupleResult.h
+	include/alibabacloud/nis/model/GetNatTopNRequest.h
+	include/alibabacloud/nis/model/GetNatTopNResult.h
+	include/alibabacloud/nis/model/GetNetworkReachableAnalysisRequest.h
+	include/alibabacloud/nis/model/GetNetworkReachableAnalysisResult.h
+	include/alibabacloud/nis/model/GetNisNetworkMetricsRequest.h
+	include/alibabacloud/nis/model/GetNisNetworkMetricsResult.h
+	include/alibabacloud/nis/model/GetNisNetworkRankingRequest.h
+	include/alibabacloud/nis/model/GetNisNetworkRankingResult.h
+	include/alibabacloud/nis/model/GetTransitRouterFlowTopNRequest.h
+	include/alibabacloud/nis/model/GetTransitRouterFlowTopNResult.h
+	include/alibabacloud/nis/model/GetVbrFlowTopNRequest.h
+	include/alibabacloud/nis/model/GetVbrFlowTopNResult.h )
+
+set(nis_src 
+	src/NisClient.cc
+	src/model/CreateAndAnalyzeNetworkPathRequest.cc
+	src/model/CreateAndAnalyzeNetworkPathResult.cc
+	src/model/CreateNetworkPathRequest.cc
+	src/model/CreateNetworkPathResult.cc
+	src/model/CreateNetworkReachableAnalysisRequest.cc
+	src/model/CreateNetworkReachableAnalysisResult.cc
+	src/model/DeleteNetworkPathRequest.cc
+	src/model/DeleteNetworkPathResult.cc
+	src/model/DeleteNetworkReachableAnalysisRequest.cc
+	src/model/DeleteNetworkReachableAnalysisResult.cc
+	src/model/GetInternetTupleRequest.cc
+	src/model/GetInternetTupleResult.cc
+	src/model/GetNatTopNRequest.cc
+	src/model/GetNatTopNResult.cc
+	src/model/GetNetworkReachableAnalysisRequest.cc
+	src/model/GetNetworkReachableAnalysisResult.cc
+	src/model/GetNisNetworkMetricsRequest.cc
+	src/model/GetNisNetworkMetricsResult.cc
+	src/model/GetNisNetworkRankingRequest.cc
+	src/model/GetNisNetworkRankingResult.cc
+	src/model/GetTransitRouterFlowTopNRequest.cc
+	src/model/GetTransitRouterFlowTopNResult.cc
+	src/model/GetVbrFlowTopNRequest.cc
+	src/model/GetVbrFlowTopNResult.cc )
+
+add_library(nis ${LIB_TYPE}
+	${nis_public_header}
+	${nis_public_header_model}
+	${nis_src})
+
+set_target_properties(nis
+	PROPERTIES
+	LINKER_LANGUAGE CXX
+	ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib
+	RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+	OUTPUT_NAME ${TARGET_OUTPUT_NAME_PREFIX}nis
+	)
+
+if(${LIB_TYPE} STREQUAL "SHARED")
+	set_target_properties(nis
+		PROPERTIES
+		DEFINE_SYMBOL ALIBABACLOUD_NIS_LIBRARY)
+endif()
+
+target_include_directories(nis
+	PRIVATE include
+		${CMAKE_SOURCE_DIR}/core/include
+	)
+target_link_libraries(nis
+	core)
+
+if(CMAKE_HOST_WIN32)
+	ExternalProject_Get_Property(jsoncpp INSTALL_DIR)
+	set(jsoncpp_install_dir ${INSTALL_DIR})
+	add_dependencies(nis
+		jsoncpp)
+	target_include_directories(nis
+		PRIVATE	${jsoncpp_install_dir}/include)
+	target_link_libraries(nis
+		${jsoncpp_install_dir}/lib/jsoncpp.lib)
+	set_target_properties(nis
+    	PROPERTIES
+    		COMPILE_OPTIONS "/bigobj")
+else()
+	target_include_directories(nis
+		PRIVATE /usr/include/jsoncpp)
+	target_link_libraries(nis
+		jsoncpp)
+endif()
+
+install(FILES ${nis_public_header}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/nis)
+install(FILES ${nis_public_header_model}
+	DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/alibabacloud/nis/model)
+install(TARGETS nis
+	ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+	RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+	)

nis/include/alibabacloud/nis/NisClient.h

@@ -0,0 +1,142 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_NISCLIENT_H_
+#define ALIBABACLOUD_NIS_NISCLIENT_H_
+
+#include <future>
+#include <alibabacloud/core/AsyncCallerContext.h>
+#include <alibabacloud/core/EndpointProvider.h>
+#include <alibabacloud/core/RpcServiceClient.h>
+#include "NisExport.h"
+#include "model/CreateAndAnalyzeNetworkPathRequest.h"
+#include "model/CreateAndAnalyzeNetworkPathResult.h"
+#include "model/CreateNetworkPathRequest.h"
+#include "model/CreateNetworkPathResult.h"
+#include "model/CreateNetworkReachableAnalysisRequest.h"
+#include "model/CreateNetworkReachableAnalysisResult.h"
+#include "model/DeleteNetworkPathRequest.h"
+#include "model/DeleteNetworkPathResult.h"
+#include "model/DeleteNetworkReachableAnalysisRequest.h"
+#include "model/DeleteNetworkReachableAnalysisResult.h"
+#include "model/GetInternetTupleRequest.h"
+#include "model/GetInternetTupleResult.h"
+#include "model/GetNatTopNRequest.h"
+#include "model/GetNatTopNResult.h"
+#include "model/GetNetworkReachableAnalysisRequest.h"
+#include "model/GetNetworkReachableAnalysisResult.h"
+#include "model/GetNisNetworkMetricsRequest.h"
+#include "model/GetNisNetworkMetricsResult.h"
+#include "model/GetNisNetworkRankingRequest.h"
+#include "model/GetNisNetworkRankingResult.h"
+#include "model/GetTransitRouterFlowTopNRequest.h"
+#include "model/GetTransitRouterFlowTopNResult.h"
+#include "model/GetVbrFlowTopNRequest.h"
+#include "model/GetVbrFlowTopNResult.h"
+
+
+namespace AlibabaCloud
+{
+	namespace Nis
+	{
+		class ALIBABACLOUD_NIS_EXPORT NisClient : public RpcServiceClient
+		{
+		public:
+			typedef Outcome<Error, Model::CreateAndAnalyzeNetworkPathResult> CreateAndAnalyzeNetworkPathOutcome;
+			typedef std::future<CreateAndAnalyzeNetworkPathOutcome> CreateAndAnalyzeNetworkPathOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::CreateAndAnalyzeNetworkPathRequest&, const CreateAndAnalyzeNetworkPathOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAndAnalyzeNetworkPathAsyncHandler;
+			typedef Outcome<Error, Model::CreateNetworkPathResult> CreateNetworkPathOutcome;
+			typedef std::future<CreateNetworkPathOutcome> CreateNetworkPathOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::CreateNetworkPathRequest&, const CreateNetworkPathOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNetworkPathAsyncHandler;
+			typedef Outcome<Error, Model::CreateNetworkReachableAnalysisResult> CreateNetworkReachableAnalysisOutcome;
+			typedef std::future<CreateNetworkReachableAnalysisOutcome> CreateNetworkReachableAnalysisOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::CreateNetworkReachableAnalysisRequest&, const CreateNetworkReachableAnalysisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateNetworkReachableAnalysisAsyncHandler;
+			typedef Outcome<Error, Model::DeleteNetworkPathResult> DeleteNetworkPathOutcome;
+			typedef std::future<DeleteNetworkPathOutcome> DeleteNetworkPathOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::DeleteNetworkPathRequest&, const DeleteNetworkPathOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNetworkPathAsyncHandler;
+			typedef Outcome<Error, Model::DeleteNetworkReachableAnalysisResult> DeleteNetworkReachableAnalysisOutcome;
+			typedef std::future<DeleteNetworkReachableAnalysisOutcome> DeleteNetworkReachableAnalysisOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::DeleteNetworkReachableAnalysisRequest&, const DeleteNetworkReachableAnalysisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteNetworkReachableAnalysisAsyncHandler;
+			typedef Outcome<Error, Model::GetInternetTupleResult> GetInternetTupleOutcome;
+			typedef std::future<GetInternetTupleOutcome> GetInternetTupleOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::GetInternetTupleRequest&, const GetInternetTupleOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetInternetTupleAsyncHandler;
+			typedef Outcome<Error, Model::GetNatTopNResult> GetNatTopNOutcome;
+			typedef std::future<GetNatTopNOutcome> GetNatTopNOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::GetNatTopNRequest&, const GetNatTopNOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNatTopNAsyncHandler;
+			typedef Outcome<Error, Model::GetNetworkReachableAnalysisResult> GetNetworkReachableAnalysisOutcome;
+			typedef std::future<GetNetworkReachableAnalysisOutcome> GetNetworkReachableAnalysisOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::GetNetworkReachableAnalysisRequest&, const GetNetworkReachableAnalysisOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNetworkReachableAnalysisAsyncHandler;
+			typedef Outcome<Error, Model::GetNisNetworkMetricsResult> GetNisNetworkMetricsOutcome;
+			typedef std::future<GetNisNetworkMetricsOutcome> GetNisNetworkMetricsOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::GetNisNetworkMetricsRequest&, const GetNisNetworkMetricsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNisNetworkMetricsAsyncHandler;
+			typedef Outcome<Error, Model::GetNisNetworkRankingResult> GetNisNetworkRankingOutcome;
+			typedef std::future<GetNisNetworkRankingOutcome> GetNisNetworkRankingOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::GetNisNetworkRankingRequest&, const GetNisNetworkRankingOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetNisNetworkRankingAsyncHandler;
+			typedef Outcome<Error, Model::GetTransitRouterFlowTopNResult> GetTransitRouterFlowTopNOutcome;
+			typedef std::future<GetTransitRouterFlowTopNOutcome> GetTransitRouterFlowTopNOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::GetTransitRouterFlowTopNRequest&, const GetTransitRouterFlowTopNOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetTransitRouterFlowTopNAsyncHandler;
+			typedef Outcome<Error, Model::GetVbrFlowTopNResult> GetVbrFlowTopNOutcome;
+			typedef std::future<GetVbrFlowTopNOutcome> GetVbrFlowTopNOutcomeCallable;
+			typedef std::function<void(const NisClient*, const Model::GetVbrFlowTopNRequest&, const GetVbrFlowTopNOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetVbrFlowTopNAsyncHandler;
+
+			NisClient(const Credentials &credentials, const ClientConfiguration &configuration);
+			NisClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
+			NisClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
+			~NisClient();
+			CreateAndAnalyzeNetworkPathOutcome createAndAnalyzeNetworkPath(const Model::CreateAndAnalyzeNetworkPathRequest &request)const;
+			void createAndAnalyzeNetworkPathAsync(const Model::CreateAndAnalyzeNetworkPathRequest& request, const CreateAndAnalyzeNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateAndAnalyzeNetworkPathOutcomeCallable createAndAnalyzeNetworkPathCallable(const Model::CreateAndAnalyzeNetworkPathRequest& request) const;
+			CreateNetworkPathOutcome createNetworkPath(const Model::CreateNetworkPathRequest &request)const;
+			void createNetworkPathAsync(const Model::CreateNetworkPathRequest& request, const CreateNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateNetworkPathOutcomeCallable createNetworkPathCallable(const Model::CreateNetworkPathRequest& request) const;
+			CreateNetworkReachableAnalysisOutcome createNetworkReachableAnalysis(const Model::CreateNetworkReachableAnalysisRequest &request)const;
+			void createNetworkReachableAnalysisAsync(const Model::CreateNetworkReachableAnalysisRequest& request, const CreateNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CreateNetworkReachableAnalysisOutcomeCallable createNetworkReachableAnalysisCallable(const Model::CreateNetworkReachableAnalysisRequest& request) const;
+			DeleteNetworkPathOutcome deleteNetworkPath(const Model::DeleteNetworkPathRequest &request)const;
+			void deleteNetworkPathAsync(const Model::DeleteNetworkPathRequest& request, const DeleteNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteNetworkPathOutcomeCallable deleteNetworkPathCallable(const Model::DeleteNetworkPathRequest& request) const;
+			DeleteNetworkReachableAnalysisOutcome deleteNetworkReachableAnalysis(const Model::DeleteNetworkReachableAnalysisRequest &request)const;
+			void deleteNetworkReachableAnalysisAsync(const Model::DeleteNetworkReachableAnalysisRequest& request, const DeleteNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DeleteNetworkReachableAnalysisOutcomeCallable deleteNetworkReachableAnalysisCallable(const Model::DeleteNetworkReachableAnalysisRequest& request) const;
+			GetInternetTupleOutcome getInternetTuple(const Model::GetInternetTupleRequest &request)const;
+			void getInternetTupleAsync(const Model::GetInternetTupleRequest& request, const GetInternetTupleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetInternetTupleOutcomeCallable getInternetTupleCallable(const Model::GetInternetTupleRequest& request) const;
+			GetNatTopNOutcome getNatTopN(const Model::GetNatTopNRequest &request)const;
+			void getNatTopNAsync(const Model::GetNatTopNRequest& request, const GetNatTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNatTopNOutcomeCallable getNatTopNCallable(const Model::GetNatTopNRequest& request) const;
+			GetNetworkReachableAnalysisOutcome getNetworkReachableAnalysis(const Model::GetNetworkReachableAnalysisRequest &request)const;
+			void getNetworkReachableAnalysisAsync(const Model::GetNetworkReachableAnalysisRequest& request, const GetNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNetworkReachableAnalysisOutcomeCallable getNetworkReachableAnalysisCallable(const Model::GetNetworkReachableAnalysisRequest& request) const;
+			GetNisNetworkMetricsOutcome getNisNetworkMetrics(const Model::GetNisNetworkMetricsRequest &request)const;
+			void getNisNetworkMetricsAsync(const Model::GetNisNetworkMetricsRequest& request, const GetNisNetworkMetricsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNisNetworkMetricsOutcomeCallable getNisNetworkMetricsCallable(const Model::GetNisNetworkMetricsRequest& request) const;
+			GetNisNetworkRankingOutcome getNisNetworkRanking(const Model::GetNisNetworkRankingRequest &request)const;
+			void getNisNetworkRankingAsync(const Model::GetNisNetworkRankingRequest& request, const GetNisNetworkRankingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetNisNetworkRankingOutcomeCallable getNisNetworkRankingCallable(const Model::GetNisNetworkRankingRequest& request) const;
+			GetTransitRouterFlowTopNOutcome getTransitRouterFlowTopN(const Model::GetTransitRouterFlowTopNRequest &request)const;
+			void getTransitRouterFlowTopNAsync(const Model::GetTransitRouterFlowTopNRequest& request, const GetTransitRouterFlowTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetTransitRouterFlowTopNOutcomeCallable getTransitRouterFlowTopNCallable(const Model::GetTransitRouterFlowTopNRequest& request) const;
+			GetVbrFlowTopNOutcome getVbrFlowTopN(const Model::GetVbrFlowTopNRequest &request)const;
+			void getVbrFlowTopNAsync(const Model::GetVbrFlowTopNRequest& request, const GetVbrFlowTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetVbrFlowTopNOutcomeCallable getVbrFlowTopNCallable(const Model::GetVbrFlowTopNRequest& request) const;
+	
+		private:
+			std::shared_ptr<EndpointProvider> endpointProvider_;
+		};
+	}
+}
+
+#endif // !ALIBABACLOUD_NIS_NISCLIENT_H_

nis/include/alibabacloud/nis/NisExport.h

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

nis/include/alibabacloud/nis/model/CreateAndAnalyzeNetworkPathRequest.h

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_CREATEANDANALYZENETWORKPATHREQUEST_H_
+#define ALIBABACLOUD_NIS_MODEL_CREATEANDANALYZENETWORKPATHREQUEST_H_
+
+#include <alibabacloud/nis/NisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nis {
+namespace Model {
+class ALIBABACLOUD_NIS_EXPORT CreateAndAnalyzeNetworkPathRequest : public RpcServiceRequest {
+public:
+	CreateAndAnalyzeNetworkPathRequest();
+	~CreateAndAnalyzeNetworkPathRequest();
+	std::string getTargetId() const;
+	void setTargetId(const std::string &targetId);
+	std::string getTargetType() const;
+	void setTargetType(const std::string &targetType);
+	std::string getTargetIpAddress() const;
+	void setTargetIpAddress(const std::string &targetIpAddress);
+	int getSourcePort() const;
+	void setSourcePort(int sourcePort);
+	std::string getProtocol() const;
+	void setProtocol(const std::string &protocol);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getSourceAliUid() const;
+	void setSourceAliUid(long sourceAliUid);
+	std::string getSourceType() const;
+	void setSourceType(const std::string &sourceType);
+	std::string getAuditParam() const;
+	void setAuditParam(const std::string &auditParam);
+	int getTargetPort() const;
+	void setTargetPort(int targetPort);
+	std::string getSourceId() const;
+	void setSourceId(const std::string &sourceId);
+	std::string getSourceIpAddress() const;
+	void setSourceIpAddress(const std::string &sourceIpAddress);
+	bool getUseMultiAccount() const;
+	void setUseMultiAccount(bool useMultiAccount);
+	long getTargetAliUid() const;
+	void setTargetAliUid(long targetAliUid);
+
+private:
+	std::string targetId_;
+	std::string targetType_;
+	std::string targetIpAddress_;
+	int sourcePort_;
+	std::string protocol_;
+	std::string regionId_;
+	long sourceAliUid_;
+	std::string sourceType_;
+	std::string auditParam_;
+	int targetPort_;
+	std::string sourceId_;
+	std::string sourceIpAddress_;
+	bool useMultiAccount_;
+	long targetAliUid_;
+};
+} // namespace Model
+} // namespace Nis
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NIS_MODEL_CREATEANDANALYZENETWORKPATHREQUEST_H_

nis/include/alibabacloud/nis/model/CreateAndAnalyzeNetworkPathResult.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_CREATEANDANALYZENETWORKPATHRESULT_H_
+#define ALIBABACLOUD_NIS_MODEL_CREATEANDANALYZENETWORKPATHRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nis/NisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nis
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NIS_EXPORT CreateAndAnalyzeNetworkPathResult : public ServiceResult
+			{
+			public:
+
+
+				CreateAndAnalyzeNetworkPathResult();
+				explicit CreateAndAnalyzeNetworkPathResult(const std::string &payload);
+				~CreateAndAnalyzeNetworkPathResult();
+				std::string getTargetPort()const;
+				std::string getNetworkReachableAnalysisId()const;
+				std::string getSourceId()const;
+				std::string getSourceType()const;
+				std::string getTargetType()const;
+				std::string getSourcePort()const;
+				std::string getProtocol()const;
+				std::string getTargetId()const;
+				std::string getSourceIpAddress()const;
+				std::string getTargetIpAddress()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string targetPort_;
+				std::string networkReachableAnalysisId_;
+				std::string sourceId_;
+				std::string sourceType_;
+				std::string targetType_;
+				std::string sourcePort_;
+				std::string protocol_;
+				std::string targetId_;
+				std::string sourceIpAddress_;
+				std::string targetIpAddress_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NIS_MODEL_CREATEANDANALYZENETWORKPATHRESULT_H_

nis/include/alibabacloud/nis/model/CreateNetworkPathRequest.h

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_CREATENETWORKPATHREQUEST_H_
+#define ALIBABACLOUD_NIS_MODEL_CREATENETWORKPATHREQUEST_H_
+
+#include <alibabacloud/nis/NisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nis {
+namespace Model {
+class ALIBABACLOUD_NIS_EXPORT CreateNetworkPathRequest : public RpcServiceRequest {
+public:
+	struct SystemTag {
+		std::string key;
+		std::string value;
+		std::string scope;
+	};
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	CreateNetworkPathRequest();
+	~CreateNetworkPathRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	std::string getTargetId() const;
+	void setTargetId(const std::string &targetId);
+	std::string getTargetType() const;
+	void setTargetType(const std::string &targetType);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::vector<SystemTag> getSystemTag() const;
+	void setSystemTag(const std::vector<SystemTag> &systemTag);
+	std::string getTargetIpAddress() const;
+	void setTargetIpAddress(const std::string &targetIpAddress);
+	std::string getNetworkPathName() const;
+	void setNetworkPathName(const std::string &networkPathName);
+	int getSourcePort() const;
+	void setSourcePort(int sourcePort);
+	std::string getResourceGroupId() const;
+	void setResourceGroupId(const std::string &resourceGroupId);
+	std::string getProtocol() const;
+	void setProtocol(const std::string &protocol);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getSourceAliUid() const;
+	void setSourceAliUid(long sourceAliUid);
+	std::string getSourceType() const;
+	void setSourceType(const std::string &sourceType);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+	int getTargetPort() const;
+	void setTargetPort(int targetPort);
+	std::string getSourceId() const;
+	void setSourceId(const std::string &sourceId);
+	std::string getSourceIpAddress() const;
+	void setSourceIpAddress(const std::string &sourceIpAddress);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	bool getUseMultiAccount() const;
+	void setUseMultiAccount(bool useMultiAccount);
+	std::string getNetworkPathDescription() const;
+	void setNetworkPathDescription(const std::string &networkPathDescription);
+	long getTargetAliUid() const;
+	void setTargetAliUid(long targetAliUid);
+
+private:
+	long resourceOwnerId_;
+	std::string targetId_;
+	std::string targetType_;
+	std::string clientToken_;
+	std::vector<SystemTag> systemTag_;
+	std::string targetIpAddress_;
+	std::string networkPathName_;
+	int sourcePort_;
+	std::string resourceGroupId_;
+	std::string protocol_;
+	std::string regionId_;
+	long sourceAliUid_;
+	std::string sourceType_;
+	std::vector<Tag> tag_;
+	int targetPort_;
+	std::string sourceId_;
+	std::string sourceIpAddress_;
+	bool dryRun_;
+	bool useMultiAccount_;
+	std::string networkPathDescription_;
+	long targetAliUid_;
+};
+} // namespace Model
+} // namespace Nis
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NIS_MODEL_CREATENETWORKPATHREQUEST_H_

nis/include/alibabacloud/nis/model/CreateNetworkPathResult.h

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

nis/include/alibabacloud/nis/model/CreateNetworkReachableAnalysisRequest.h

@@ -0,0 +1,72 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_CREATENETWORKREACHABLEANALYSISREQUEST_H_
+#define ALIBABACLOUD_NIS_MODEL_CREATENETWORKREACHABLEANALYSISREQUEST_H_
+
+#include <alibabacloud/nis/NisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nis {
+namespace Model {
+class ALIBABACLOUD_NIS_EXPORT CreateNetworkReachableAnalysisRequest : public RpcServiceRequest {
+public:
+	struct SystemTag {
+		std::string key;
+		std::string value;
+		std::string scope;
+	};
+	struct Tag {
+		std::string key;
+		std::string value;
+	};
+	CreateNetworkReachableAnalysisRequest();
+	~CreateNetworkReachableAnalysisRequest();
+	long getResourceOwnerId() const;
+	void setResourceOwnerId(long resourceOwnerId);
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::vector<SystemTag> getSystemTag() const;
+	void setSystemTag(const std::vector<SystemTag> &systemTag);
+	std::string getNetworkPathId() const;
+	void setNetworkPathId(const std::string &networkPathId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getAuditParam() const;
+	void setAuditParam(const std::string &auditParam);
+	std::vector<Tag> getTag() const;
+	void setTag(const std::vector<Tag> &tag);
+
+private:
+	long resourceOwnerId_;
+	bool dryRun_;
+	std::string clientToken_;
+	std::vector<SystemTag> systemTag_;
+	std::string networkPathId_;
+	std::string regionId_;
+	std::string auditParam_;
+	std::vector<Tag> tag_;
+};
+} // namespace Model
+} // namespace Nis
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NIS_MODEL_CREATENETWORKREACHABLEANALYSISREQUEST_H_

nis/include/alibabacloud/nis/model/CreateNetworkReachableAnalysisResult.h

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

nis/include/alibabacloud/nis/model/DeleteNetworkPathRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_DELETENETWORKPATHREQUEST_H_
+#define ALIBABACLOUD_NIS_MODEL_DELETENETWORKPATHREQUEST_H_
+
+#include <alibabacloud/nis/NisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nis {
+namespace Model {
+class ALIBABACLOUD_NIS_EXPORT DeleteNetworkPathRequest : public RpcServiceRequest {
+public:
+	DeleteNetworkPathRequest();
+	~DeleteNetworkPathRequest();
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::vector<std::string> getNetworkPathIds() const;
+	void setNetworkPathIds(const std::vector<std::string> &networkPathIds);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+
+private:
+	bool dryRun_;
+	std::string clientToken_;
+	std::vector<std::string> networkPathIds_;
+	std::string regionId_;
+};
+} // namespace Model
+} // namespace Nis
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NIS_MODEL_DELETENETWORKPATHREQUEST_H_

nis/include/alibabacloud/nis/model/DeleteNetworkPathResult.h

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

nis/include/alibabacloud/nis/model/DeleteNetworkReachableAnalysisRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_DELETENETWORKREACHABLEANALYSISREQUEST_H_
+#define ALIBABACLOUD_NIS_MODEL_DELETENETWORKREACHABLEANALYSISREQUEST_H_
+
+#include <alibabacloud/nis/NisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nis {
+namespace Model {
+class ALIBABACLOUD_NIS_EXPORT DeleteNetworkReachableAnalysisRequest : public RpcServiceRequest {
+public:
+	DeleteNetworkReachableAnalysisRequest();
+	~DeleteNetworkReachableAnalysisRequest();
+	bool getDryRun() const;
+	void setDryRun(bool dryRun);
+	std::string getClientToken() const;
+	void setClientToken(const std::string &clientToken);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::vector<std::string> getNetworkReachableAnalysisIds() const;
+	void setNetworkReachableAnalysisIds(const std::vector<std::string> &networkReachableAnalysisIds);
+
+private:
+	bool dryRun_;
+	std::string clientToken_;
+	std::string regionId_;
+	std::vector<std::string> networkReachableAnalysisIds_;
+};
+} // namespace Model
+} // namespace Nis
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NIS_MODEL_DELETENETWORKREACHABLEANALYSISREQUEST_H_

nis/include/alibabacloud/nis/model/DeleteNetworkReachableAnalysisResult.h

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

nis/include/alibabacloud/nis/model/GetInternetTupleRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETINTERNETTUPLEREQUEST_H_
+#define ALIBABACLOUD_NIS_MODEL_GETINTERNETTUPLEREQUEST_H_
+
+#include <alibabacloud/nis/NisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nis {
+namespace Model {
+class ALIBABACLOUD_NIS_EXPORT GetInternetTupleRequest : public RpcServiceRequest {
+public:
+	GetInternetTupleRequest();
+	~GetInternetTupleRequest();
+	std::string getOtherPort() const;
+	void setOtherPort(const std::string &otherPort);
+	std::string getCloudIsp() const;
+	void setCloudIsp(const std::string &cloudIsp);
+	int getTopN() const;
+	void setTopN(int topN);
+	std::string getCloudPort() const;
+	void setCloudPort(const std::string &cloudPort);
+	std::string getProtocol() const;
+	void setProtocol(const std::string &protocol);
+	std::string getOtherIp() const;
+	void setOtherIp(const std::string &otherIp);
+	std::vector<std::string> getInstanceList() const;
+	void setInstanceList(const std::vector<std::string> &instanceList);
+	std::string getOrderBy() const;
+	void setOrderBy(const std::string &orderBy);
+	std::string getSort() const;
+	void setSort(const std::string &sort);
+	bool getUseMultiAccount() const;
+	void setUseMultiAccount(bool useMultiAccount);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	int getTupleType() const;
+	void setTupleType(int tupleType);
+	std::string getCloudIp() const;
+	void setCloudIp(const std::string &cloudIp);
+	std::vector<std::string> getCloudIpList() const;
+	void setCloudIpList(const std::vector<std::string> &cloudIpList);
+	std::string getOtherIsp() const;
+	void setOtherIsp(const std::string &otherIsp);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getOtherCountry() const;
+	void setOtherCountry(const std::string &otherCountry);
+	std::string getDirection() const;
+	void setDirection(const std::string &direction);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getBeginTime() const;
+	void setBeginTime(long beginTime);
+	std::string getOtherCity() const;
+	void setOtherCity(const std::string &otherCity);
+	std::vector<long> getAccountIds() const;
+	void setAccountIds(const std::vector<long> &accountIds);
+
+private:
+	std::string otherPort_;
+	std::string cloudIsp_;
+	int topN_;
+	std::string cloudPort_;
+	std::string protocol_;
+	std::string otherIp_;
+	std::vector<std::string> instanceList_;
+	std::string orderBy_;
+	std::string sort_;
+	bool useMultiAccount_;
+	std::string instanceId_;
+	int tupleType_;
+	std::string cloudIp_;
+	std::vector<std::string> cloudIpList_;
+	std::string otherIsp_;
+	std::string regionId_;
+	std::string otherCountry_;
+	std::string direction_;
+	long endTime_;
+	long beginTime_;
+	std::string otherCity_;
+	std::vector<long> accountIds_;
+};
+} // namespace Model
+} // namespace Nis
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NIS_MODEL_GETINTERNETTUPLEREQUEST_H_

nis/include/alibabacloud/nis/model/GetInternetTupleResult.h

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETINTERNETTUPLERESULT_H_
+#define ALIBABACLOUD_NIS_MODEL_GETINTERNETTUPLERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nis/NisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nis
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NIS_EXPORT GetInternetTupleResult : public ServiceResult
+			{
+			public:
+				struct DataItem
+				{
+					std::string cloudIp;
+					double inRetranCount;
+					double outPacketCount;
+					std::string otherProvince;
+					std::string beginTime;
+					std::string otherProduct;
+					double packetCount;
+					double inByteCount;
+					std::string direction;
+					std::string cloudProduct;
+					std::string otherIp;
+					double rtt;
+					std::string cloudProvince;
+					std::string otherCity;
+					std::string otherCountry;
+					double outByteCount;
+					std::string protocol;
+					std::string cloudCountry;
+					double inPacketCount;
+					std::string cloudCity;
+					double byteCount;
+					std::string instanceId;
+					std::string otherPort;
+					double outOutOrderCount;
+					double retranCount;
+					double outRetranCount;
+					std::string cloudIsp;
+					std::string accessRegion;
+					double retransmitRate;
+					double inOutOrderCount;
+					double outOrderCount;
+					std::string otherIsp;
+					std::string cloudPort;
+				};
+
+
+				GetInternetTupleResult();
+				explicit GetInternetTupleResult(const std::string &payload);
+				~GetInternetTupleResult();
+				std::vector<DataItem> getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DataItem> data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NIS_MODEL_GETINTERNETTUPLERESULT_H_

nis/include/alibabacloud/nis/model/GetNatTopNRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETNATTOPNREQUEST_H_
+#define ALIBABACLOUD_NIS_MODEL_GETNATTOPNREQUEST_H_
+
+#include <alibabacloud/nis/NisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nis {
+namespace Model {
+class ALIBABACLOUD_NIS_EXPORT GetNatTopNRequest : public RpcServiceRequest {
+public:
+	GetNatTopNRequest();
+	~GetNatTopNRequest();
+	std::string getIp() const;
+	void setIp(const std::string &ip);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	std::string getOrderBy() const;
+	void setOrderBy(const std::string &orderBy);
+	long getBeginTime() const;
+	void setBeginTime(long beginTime);
+	int getTopN() const;
+	void setTopN(int topN);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getNatGatewayId() const;
+	void setNatGatewayId(const std::string &natGatewayId);
+
+private:
+	std::string ip_;
+	long endTime_;
+	std::string orderBy_;
+	long beginTime_;
+	int topN_;
+	std::string regionId_;
+	std::string natGatewayId_;
+};
+} // namespace Model
+} // namespace Nis
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NIS_MODEL_GETNATTOPNREQUEST_H_

nis/include/alibabacloud/nis/model/GetNatTopNResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETNATTOPNRESULT_H_
+#define ALIBABACLOUD_NIS_MODEL_GETNATTOPNRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nis/NisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nis
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NIS_EXPORT GetNatTopNResult : public ServiceResult
+			{
+			public:
+				struct NatGatewayTopNItem
+				{
+					float outPps;
+					float outBps;
+					std::string ip;
+					float inBps;
+					float newSessionPerSecond;
+					float outFlowPerMinute;
+					float inPps;
+					float activeSessionCount;
+					float inFlowPerMinute;
+				};
+
+
+				GetNatTopNResult();
+				explicit GetNatTopNResult(const std::string &payload);
+				~GetNatTopNResult();
+				std::vector<NatGatewayTopNItem> getNatGatewayTopN()const;
+				bool getIsTopNOpen()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<NatGatewayTopNItem> natGatewayTopN_;
+				bool isTopNOpen_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NIS_MODEL_GETNATTOPNRESULT_H_

nis/include/alibabacloud/nis/model/GetNetworkReachableAnalysisRequest.h

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

nis/include/alibabacloud/nis/model/GetNetworkReachableAnalysisResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETNETWORKREACHABLEANALYSISRESULT_H_
+#define ALIBABACLOUD_NIS_MODEL_GETNETWORKREACHABLEANALYSISRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nis/NisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nis
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NIS_EXPORT GetNetworkReachableAnalysisResult : public ServiceResult
+			{
+			public:
+
+
+				GetNetworkReachableAnalysisResult();
+				explicit GetNetworkReachableAnalysisResult(const std::string &payload);
+				~GetNetworkReachableAnalysisResult();
+				std::string getNetworkReachableAnalysisId()const;
+				std::string getCreateTime()const;
+				bool getReachable()const;
+				std::string getNetworkPathId()const;
+				std::string getNetworkReachableAnalysisResult()const;
+				std::string getNetworkReachableAnalysisStatus()const;
+				long getAliUid()const;
+				std::string getNetworkPathParameter()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string networkReachableAnalysisId_;
+				std::string createTime_;
+				bool reachable_;
+				std::string networkPathId_;
+				std::string networkReachableAnalysisResult_;
+				std::string networkReachableAnalysisStatus_;
+				long aliUid_;
+				std::string networkPathParameter_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NIS_MODEL_GETNETWORKREACHABLEANALYSISRESULT_H_

nis/include/alibabacloud/nis/model/GetNisNetworkMetricsRequest.h

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETNISNETWORKMETRICSREQUEST_H_
+#define ALIBABACLOUD_NIS_MODEL_GETNISNETWORKMETRICSREQUEST_H_
+
+#include <alibabacloud/nis/NisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nis {
+namespace Model {
+class ALIBABACLOUD_NIS_EXPORT GetNisNetworkMetricsRequest : public RpcServiceRequest {
+public:
+	struct Dimensions {
+		std::string name;
+		std::string value;
+	};
+	GetNisNetworkMetricsRequest();
+	~GetNisNetworkMetricsRequest();
+	bool getUseCrossAccount() const;
+	void setUseCrossAccount(bool useCrossAccount);
+	std::string getScanBy() const;
+	void setScanBy(const std::string &scanBy);
+	std::string getMetricName() const;
+	void setMetricName(const std::string &metricName);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getBeginTime() const;
+	void setBeginTime(long beginTime);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	std::string getRegionNo() const;
+	void setRegionNo(const std::string &regionNo);
+	std::vector<std::string> getAccountIds() const;
+	void setAccountIds(const std::vector<std::string> &accountIds);
+	std::vector<Dimensions> getDimensions() const;
+	void setDimensions(const std::vector<Dimensions> &dimensions);
+
+private:
+	bool useCrossAccount_;
+	std::string scanBy_;
+	std::string metricName_;
+	long endTime_;
+	long beginTime_;
+	std::string resourceType_;
+	std::string regionNo_;
+	std::vector<std::string> accountIds_;
+	std::vector<Dimensions> dimensions_;
+};
+} // namespace Model
+} // namespace Nis
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NIS_MODEL_GETNISNETWORKMETRICSREQUEST_H_

nis/include/alibabacloud/nis/model/GetNisNetworkMetricsResult.h

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

nis/include/alibabacloud/nis/model/GetNisNetworkRankingRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETNISNETWORKRANKINGREQUEST_H_
+#define ALIBABACLOUD_NIS_MODEL_GETNISNETWORKRANKINGREQUEST_H_
+
+#include <alibabacloud/nis/NisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nis {
+namespace Model {
+class ALIBABACLOUD_NIS_EXPORT GetNisNetworkRankingRequest : public RpcServiceRequest {
+public:
+	struct Filter {
+		std::string name;
+		std::string value;
+	};
+	GetNisNetworkRankingRequest();
+	~GetNisNetworkRankingRequest();
+	bool getUseCrossAccount() const;
+	void setUseCrossAccount(bool useCrossAccount);
+	int getTopN() const;
+	void setTopN(int topN);
+	std::string getDirection() const;
+	void setDirection(const std::string &direction);
+	std::string getOrderBy() const;
+	void setOrderBy(const std::string &orderBy);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getBeginTime() const;
+	void setBeginTime(long beginTime);
+	std::string getGroupBy() const;
+	void setGroupBy(const std::string &groupBy);
+	std::string getSort() const;
+	void setSort(const std::string &sort);
+	std::string getResourceType() const;
+	void setResourceType(const std::string &resourceType);
+	std::string getRegionNo() const;
+	void setRegionNo(const std::string &regionNo);
+	std::vector<Filter> getFilter() const;
+	void setFilter(const std::vector<Filter> &filter);
+	std::vector<std::string> getAccountIds() const;
+	void setAccountIds(const std::vector<std::string> &accountIds);
+
+private:
+	bool useCrossAccount_;
+	int topN_;
+	std::string direction_;
+	std::string orderBy_;
+	long endTime_;
+	long beginTime_;
+	std::string groupBy_;
+	std::string sort_;
+	std::string resourceType_;
+	std::string regionNo_;
+	std::vector<Filter> filter_;
+	std::vector<std::string> accountIds_;
+};
+} // namespace Model
+} // namespace Nis
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NIS_MODEL_GETNISNETWORKRANKINGREQUEST_H_

nis/include/alibabacloud/nis/model/GetNisNetworkRankingResult.h

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETNISNETWORKRANKINGRESULT_H_
+#define ALIBABACLOUD_NIS_MODEL_GETNISNETWORKRANKINGRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nis/NisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nis
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NIS_EXPORT GetNisNetworkRankingResult : public ServiceResult
+			{
+			public:
+				struct Rankings
+				{
+					std::string regionNo;
+					std::string destinationIsp;
+					double activeSessionCount;
+					std::string destinationRegionNo;
+					std::string vbrId;
+					double packetCount;
+					std::string sourcePort;
+					std::string destinationPort;
+					double outPps;
+					std::string destinationIp;
+					std::string sourceZone;
+					double rTT;
+					double inBps;
+					std::string bandwidthPackageId;
+					double inPps;
+					std::string protocol;
+					std::string asn;
+					double outBps;
+					double byteCount;
+					std::string instanceId;
+					std::string isp;
+					std::string iP;
+					double newSessionPerSecond;
+					std::string city;
+					std::string province;
+					std::string attachmentId;
+					double retransmitRate;
+					std::string sourceIp;
+					std::string country;
+					std::string destinationZone;
+					std::string sourceIsp;
+				};
+
+
+				GetNisNetworkRankingResult();
+				explicit GetNisNetworkRankingResult(const std::string &payload);
+				~GetNisNetworkRankingResult();
+				std::vector<Rankings> getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<Rankings> data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NIS_MODEL_GETNISNETWORKRANKINGRESULT_H_

nis/include/alibabacloud/nis/model/GetTransitRouterFlowTopNRequest.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNREQUEST_H_
+#define ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNREQUEST_H_
+
+#include <alibabacloud/nis/NisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nis {
+namespace Model {
+class ALIBABACLOUD_NIS_EXPORT GetTransitRouterFlowTopNRequest : public RpcServiceRequest {
+public:
+	GetTransitRouterFlowTopNRequest();
+	~GetTransitRouterFlowTopNRequest();
+	std::string getOtherPort() const;
+	void setOtherPort(const std::string &otherPort);
+	int getTopN() const;
+	void setTopN(int topN);
+	std::string getProtocol() const;
+	void setProtocol(const std::string &protocol);
+	std::string getThisIp() const;
+	void setThisIp(const std::string &thisIp);
+	std::string getOtherIp() const;
+	void setOtherIp(const std::string &otherIp);
+	std::string getBandwithPackageId() const;
+	void setBandwithPackageId(const std::string &bandwithPackageId);
+	std::string getOrderBy() const;
+	void setOrderBy(const std::string &orderBy);
+	std::string getSort() const;
+	void setSort(const std::string &sort);
+	bool getUseMultiAccount() const;
+	void setUseMultiAccount(bool useMultiAccount);
+	std::string getThisRegion() const;
+	void setThisRegion(const std::string &thisRegion);
+	std::string getCenId() const;
+	void setCenId(const std::string &cenId);
+	std::string getThisPort() const;
+	void setThisPort(const std::string &thisPort);
+	std::string getDirection() const;
+	void setDirection(const std::string &direction);
+	std::string getOtherRegion() const;
+	void setOtherRegion(const std::string &otherRegion);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getBeginTime() const;
+	void setBeginTime(long beginTime);
+	std::string getGroupBy() const;
+	void setGroupBy(const std::string &groupBy);
+	std::vector<long> getAccountIds() const;
+	void setAccountIds(const std::vector<long> &accountIds);
+
+private:
+	std::string otherPort_;
+	int topN_;
+	std::string protocol_;
+	std::string thisIp_;
+	std::string otherIp_;
+	std::string bandwithPackageId_;
+	std::string orderBy_;
+	std::string sort_;
+	bool useMultiAccount_;
+	std::string thisRegion_;
+	std::string cenId_;
+	std::string thisPort_;
+	std::string direction_;
+	std::string otherRegion_;
+	long endTime_;
+	long beginTime_;
+	std::string groupBy_;
+	std::vector<long> accountIds_;
+};
+} // namespace Model
+} // namespace Nis
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNREQUEST_H_

nis/include/alibabacloud/nis/model/GetTransitRouterFlowTopNResult.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNRESULT_H_
+#define ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nis/NisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nis
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NIS_EXPORT GetTransitRouterFlowTopNResult : public ServiceResult
+			{
+			public:
+				struct TrFlowlogTopN
+				{
+					std::string accountId;
+					std::string endTime;
+					std::string otherPort;
+					std::string thisIp;
+					std::string startTime;
+					std::string thisRegion;
+					std::string thisPort;
+					std::string otherIp;
+					double bytes;
+					std::string otherRegion;
+					double packets;
+					std::string bandwithPackageId;
+					std::string cenId;
+					std::string protocol;
+				};
+
+
+				GetTransitRouterFlowTopNResult();
+				explicit GetTransitRouterFlowTopNResult(const std::string &payload);
+				~GetTransitRouterFlowTopNResult();
+				std::vector<TrFlowlogTopN> getTransitRouterFlowTopN()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<TrFlowlogTopN> transitRouterFlowTopN_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NIS_MODEL_GETTRANSITROUTERFLOWTOPNRESULT_H_

nis/include/alibabacloud/nis/model/GetVbrFlowTopNRequest.h

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETVBRFLOWTOPNREQUEST_H_
+#define ALIBABACLOUD_NIS_MODEL_GETVBRFLOWTOPNREQUEST_H_
+
+#include <alibabacloud/nis/NisExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Nis {
+namespace Model {
+class ALIBABACLOUD_NIS_EXPORT GetVbrFlowTopNRequest : public RpcServiceRequest {
+public:
+	GetVbrFlowTopNRequest();
+	~GetVbrFlowTopNRequest();
+	std::string getOtherPort() const;
+	void setOtherPort(const std::string &otherPort);
+	int getTopN() const;
+	void setTopN(int topN);
+	std::string getCloudPort() const;
+	void setCloudPort(const std::string &cloudPort);
+	std::string getProtocol() const;
+	void setProtocol(const std::string &protocol);
+	std::string getOtherIp() const;
+	void setOtherIp(const std::string &otherIp);
+	std::string getOrderBy() const;
+	void setOrderBy(const std::string &orderBy);
+	std::string getSort() const;
+	void setSort(const std::string &sort);
+	bool getUseMultiAccount() const;
+	void setUseMultiAccount(bool useMultiAccount);
+	std::string getCloudIp() const;
+	void setCloudIp(const std::string &cloudIp);
+	std::string getCenId() const;
+	void setCenId(const std::string &cenId);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	std::string getVirtualBorderRouterId() const;
+	void setVirtualBorderRouterId(const std::string &virtualBorderRouterId);
+	std::string getDirection() const;
+	void setDirection(const std::string &direction);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getBeginTime() const;
+	void setBeginTime(long beginTime);
+	std::string getGroupBy() const;
+	void setGroupBy(const std::string &groupBy);
+	std::vector<long> getAccountIds() const;
+	void setAccountIds(const std::vector<long> &accountIds);
+	std::string getAttachmentId() const;
+	void setAttachmentId(const std::string &attachmentId);
+
+private:
+	std::string otherPort_;
+	int topN_;
+	std::string cloudPort_;
+	std::string protocol_;
+	std::string otherIp_;
+	std::string orderBy_;
+	std::string sort_;
+	bool useMultiAccount_;
+	std::string cloudIp_;
+	std::string cenId_;
+	std::string regionId_;
+	std::string virtualBorderRouterId_;
+	std::string direction_;
+	long endTime_;
+	long beginTime_;
+	std::string groupBy_;
+	std::vector<long> accountIds_;
+	std::string attachmentId_;
+};
+} // namespace Model
+} // namespace Nis
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_NIS_MODEL_GETVBRFLOWTOPNREQUEST_H_

nis/include/alibabacloud/nis/model/GetVbrFlowTopNResult.h

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_NIS_MODEL_GETVBRFLOWTOPNRESULT_H_
+#define ALIBABACLOUD_NIS_MODEL_GETVBRFLOWTOPNRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/nis/NisExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Nis
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_NIS_EXPORT GetVbrFlowTopNResult : public ServiceResult
+			{
+			public:
+				struct VbrFlowlogTopN
+				{
+					std::string otherIp;
+					std::string cloudRegion;
+					double bytes;
+					std::string cloudIp;
+					std::string accountId;
+					std::string otherPort;
+					double packets;
+					std::string protocol;
+					std::string attachmentId;
+					std::string virtualBorderRouterId;
+					std::string cloudPort;
+				};
+
+
+				GetVbrFlowTopNResult();
+				explicit GetVbrFlowTopNResult(const std::string &payload);
+				~GetVbrFlowTopNResult();
+				std::vector<VbrFlowlogTopN> getVirtualBorderRouterFlowlogTopN()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<VbrFlowlogTopN> virtualBorderRouterFlowlogTopN_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_NIS_MODEL_GETVBRFLOWTOPNRESULT_H_

nis/src/NisClient.cc

@@ -0,0 +1,485 @@
+/*
+ * 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/nis/NisClient.h>
+#include <alibabacloud/core/SimpleCredentialsProvider.h>
+
+using namespace AlibabaCloud;
+using namespace AlibabaCloud::Location;
+using namespace AlibabaCloud::Nis;
+using namespace AlibabaCloud::Nis::Model;
+
+namespace
+{
+	const std::string SERVICE_NAME = "nis";
+}
+
+NisClient::NisClient(const Credentials &credentials, const ClientConfiguration &configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "networkana");
+}
+
+NisClient::NisClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "networkana");
+}
+
+NisClient::NisClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
+	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
+{
+	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "networkana");
+}
+
+NisClient::~NisClient()
+{}
+
+NisClient::CreateAndAnalyzeNetworkPathOutcome NisClient::createAndAnalyzeNetworkPath(const CreateAndAnalyzeNetworkPathRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateAndAnalyzeNetworkPathOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateAndAnalyzeNetworkPathOutcome(CreateAndAnalyzeNetworkPathResult(outcome.result()));
+	else
+		return CreateAndAnalyzeNetworkPathOutcome(outcome.error());
+}
+
+void NisClient::createAndAnalyzeNetworkPathAsync(const CreateAndAnalyzeNetworkPathRequest& request, const CreateAndAnalyzeNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createAndAnalyzeNetworkPath(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::CreateAndAnalyzeNetworkPathOutcomeCallable NisClient::createAndAnalyzeNetworkPathCallable(const CreateAndAnalyzeNetworkPathRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateAndAnalyzeNetworkPathOutcome()>>(
+			[this, request]()
+			{
+			return this->createAndAnalyzeNetworkPath(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NisClient::CreateNetworkPathOutcome NisClient::createNetworkPath(const CreateNetworkPathRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateNetworkPathOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateNetworkPathOutcome(CreateNetworkPathResult(outcome.result()));
+	else
+		return CreateNetworkPathOutcome(outcome.error());
+}
+
+void NisClient::createNetworkPathAsync(const CreateNetworkPathRequest& request, const CreateNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createNetworkPath(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::CreateNetworkPathOutcomeCallable NisClient::createNetworkPathCallable(const CreateNetworkPathRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateNetworkPathOutcome()>>(
+			[this, request]()
+			{
+			return this->createNetworkPath(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NisClient::CreateNetworkReachableAnalysisOutcome NisClient::createNetworkReachableAnalysis(const CreateNetworkReachableAnalysisRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateNetworkReachableAnalysisOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateNetworkReachableAnalysisOutcome(CreateNetworkReachableAnalysisResult(outcome.result()));
+	else
+		return CreateNetworkReachableAnalysisOutcome(outcome.error());
+}
+
+void NisClient::createNetworkReachableAnalysisAsync(const CreateNetworkReachableAnalysisRequest& request, const CreateNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createNetworkReachableAnalysis(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::CreateNetworkReachableAnalysisOutcomeCallable NisClient::createNetworkReachableAnalysisCallable(const CreateNetworkReachableAnalysisRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateNetworkReachableAnalysisOutcome()>>(
+			[this, request]()
+			{
+			return this->createNetworkReachableAnalysis(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NisClient::DeleteNetworkPathOutcome NisClient::deleteNetworkPath(const DeleteNetworkPathRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteNetworkPathOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteNetworkPathOutcome(DeleteNetworkPathResult(outcome.result()));
+	else
+		return DeleteNetworkPathOutcome(outcome.error());
+}
+
+void NisClient::deleteNetworkPathAsync(const DeleteNetworkPathRequest& request, const DeleteNetworkPathAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteNetworkPath(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::DeleteNetworkPathOutcomeCallable NisClient::deleteNetworkPathCallable(const DeleteNetworkPathRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteNetworkPathOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteNetworkPath(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NisClient::DeleteNetworkReachableAnalysisOutcome NisClient::deleteNetworkReachableAnalysis(const DeleteNetworkReachableAnalysisRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteNetworkReachableAnalysisOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteNetworkReachableAnalysisOutcome(DeleteNetworkReachableAnalysisResult(outcome.result()));
+	else
+		return DeleteNetworkReachableAnalysisOutcome(outcome.error());
+}
+
+void NisClient::deleteNetworkReachableAnalysisAsync(const DeleteNetworkReachableAnalysisRequest& request, const DeleteNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteNetworkReachableAnalysis(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::DeleteNetworkReachableAnalysisOutcomeCallable NisClient::deleteNetworkReachableAnalysisCallable(const DeleteNetworkReachableAnalysisRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteNetworkReachableAnalysisOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteNetworkReachableAnalysis(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NisClient::GetInternetTupleOutcome NisClient::getInternetTuple(const GetInternetTupleRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetInternetTupleOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetInternetTupleOutcome(GetInternetTupleResult(outcome.result()));
+	else
+		return GetInternetTupleOutcome(outcome.error());
+}
+
+void NisClient::getInternetTupleAsync(const GetInternetTupleRequest& request, const GetInternetTupleAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getInternetTuple(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::GetInternetTupleOutcomeCallable NisClient::getInternetTupleCallable(const GetInternetTupleRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetInternetTupleOutcome()>>(
+			[this, request]()
+			{
+			return this->getInternetTuple(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NisClient::GetNatTopNOutcome NisClient::getNatTopN(const GetNatTopNRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetNatTopNOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetNatTopNOutcome(GetNatTopNResult(outcome.result()));
+	else
+		return GetNatTopNOutcome(outcome.error());
+}
+
+void NisClient::getNatTopNAsync(const GetNatTopNRequest& request, const GetNatTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getNatTopN(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::GetNatTopNOutcomeCallable NisClient::getNatTopNCallable(const GetNatTopNRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetNatTopNOutcome()>>(
+			[this, request]()
+			{
+			return this->getNatTopN(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NisClient::GetNetworkReachableAnalysisOutcome NisClient::getNetworkReachableAnalysis(const GetNetworkReachableAnalysisRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetNetworkReachableAnalysisOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetNetworkReachableAnalysisOutcome(GetNetworkReachableAnalysisResult(outcome.result()));
+	else
+		return GetNetworkReachableAnalysisOutcome(outcome.error());
+}
+
+void NisClient::getNetworkReachableAnalysisAsync(const GetNetworkReachableAnalysisRequest& request, const GetNetworkReachableAnalysisAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getNetworkReachableAnalysis(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::GetNetworkReachableAnalysisOutcomeCallable NisClient::getNetworkReachableAnalysisCallable(const GetNetworkReachableAnalysisRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetNetworkReachableAnalysisOutcome()>>(
+			[this, request]()
+			{
+			return this->getNetworkReachableAnalysis(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NisClient::GetNisNetworkMetricsOutcome NisClient::getNisNetworkMetrics(const GetNisNetworkMetricsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetNisNetworkMetricsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetNisNetworkMetricsOutcome(GetNisNetworkMetricsResult(outcome.result()));
+	else
+		return GetNisNetworkMetricsOutcome(outcome.error());
+}
+
+void NisClient::getNisNetworkMetricsAsync(const GetNisNetworkMetricsRequest& request, const GetNisNetworkMetricsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getNisNetworkMetrics(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::GetNisNetworkMetricsOutcomeCallable NisClient::getNisNetworkMetricsCallable(const GetNisNetworkMetricsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetNisNetworkMetricsOutcome()>>(
+			[this, request]()
+			{
+			return this->getNisNetworkMetrics(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NisClient::GetNisNetworkRankingOutcome NisClient::getNisNetworkRanking(const GetNisNetworkRankingRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetNisNetworkRankingOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetNisNetworkRankingOutcome(GetNisNetworkRankingResult(outcome.result()));
+	else
+		return GetNisNetworkRankingOutcome(outcome.error());
+}
+
+void NisClient::getNisNetworkRankingAsync(const GetNisNetworkRankingRequest& request, const GetNisNetworkRankingAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getNisNetworkRanking(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::GetNisNetworkRankingOutcomeCallable NisClient::getNisNetworkRankingCallable(const GetNisNetworkRankingRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetNisNetworkRankingOutcome()>>(
+			[this, request]()
+			{
+			return this->getNisNetworkRanking(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NisClient::GetTransitRouterFlowTopNOutcome NisClient::getTransitRouterFlowTopN(const GetTransitRouterFlowTopNRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetTransitRouterFlowTopNOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetTransitRouterFlowTopNOutcome(GetTransitRouterFlowTopNResult(outcome.result()));
+	else
+		return GetTransitRouterFlowTopNOutcome(outcome.error());
+}
+
+void NisClient::getTransitRouterFlowTopNAsync(const GetTransitRouterFlowTopNRequest& request, const GetTransitRouterFlowTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getTransitRouterFlowTopN(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::GetTransitRouterFlowTopNOutcomeCallable NisClient::getTransitRouterFlowTopNCallable(const GetTransitRouterFlowTopNRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetTransitRouterFlowTopNOutcome()>>(
+			[this, request]()
+			{
+			return this->getTransitRouterFlowTopN(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+NisClient::GetVbrFlowTopNOutcome NisClient::getVbrFlowTopN(const GetVbrFlowTopNRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetVbrFlowTopNOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetVbrFlowTopNOutcome(GetVbrFlowTopNResult(outcome.result()));
+	else
+		return GetVbrFlowTopNOutcome(outcome.error());
+}
+
+void NisClient::getVbrFlowTopNAsync(const GetVbrFlowTopNRequest& request, const GetVbrFlowTopNAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getVbrFlowTopN(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+NisClient::GetVbrFlowTopNOutcomeCallable NisClient::getVbrFlowTopNCallable(const GetVbrFlowTopNRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetVbrFlowTopNOutcome()>>(
+			[this, request]()
+			{
+			return this->getVbrFlowTopN(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+

nis/src/model/CreateAndAnalyzeNetworkPathRequest.cc

@@ -0,0 +1,153 @@
+/*
+ * 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/nis/model/CreateAndAnalyzeNetworkPathRequest.h>
+
+using AlibabaCloud::Nis::Model::CreateAndAnalyzeNetworkPathRequest;
+
+CreateAndAnalyzeNetworkPathRequest::CreateAndAnalyzeNetworkPathRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "CreateAndAnalyzeNetworkPath") {
+  setMethod(HttpRequest::Method::Get);
+}
+
+CreateAndAnalyzeNetworkPathRequest::~CreateAndAnalyzeNetworkPathRequest() {}
+
+std::string CreateAndAnalyzeNetworkPathRequest::getTargetId() const {
+  return targetId_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setTargetId(const std::string &targetId) {
+  targetId_ = targetId;
+  setParameter(std::string("TargetId"), targetId);
+}
+
+std::string CreateAndAnalyzeNetworkPathRequest::getTargetType() const {
+  return targetType_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setTargetType(const std::string &targetType) {
+  targetType_ = targetType;
+  setParameter(std::string("TargetType"), targetType);
+}
+
+std::string CreateAndAnalyzeNetworkPathRequest::getTargetIpAddress() const {
+  return targetIpAddress_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setTargetIpAddress(const std::string &targetIpAddress) {
+  targetIpAddress_ = targetIpAddress;
+  setParameter(std::string("TargetIpAddress"), targetIpAddress);
+}
+
+int CreateAndAnalyzeNetworkPathRequest::getSourcePort() const {
+  return sourcePort_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setSourcePort(int sourcePort) {
+  sourcePort_ = sourcePort;
+  setParameter(std::string("SourcePort"), std::to_string(sourcePort));
+}
+
+std::string CreateAndAnalyzeNetworkPathRequest::getProtocol() const {
+  return protocol_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setProtocol(const std::string &protocol) {
+  protocol_ = protocol;
+  setParameter(std::string("Protocol"), protocol);
+}
+
+std::string CreateAndAnalyzeNetworkPathRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+long CreateAndAnalyzeNetworkPathRequest::getSourceAliUid() const {
+  return sourceAliUid_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setSourceAliUid(long sourceAliUid) {
+  sourceAliUid_ = sourceAliUid;
+  setParameter(std::string("SourceAliUid"), std::to_string(sourceAliUid));
+}
+
+std::string CreateAndAnalyzeNetworkPathRequest::getSourceType() const {
+  return sourceType_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setSourceType(const std::string &sourceType) {
+  sourceType_ = sourceType;
+  setParameter(std::string("SourceType"), sourceType);
+}
+
+std::string CreateAndAnalyzeNetworkPathRequest::getAuditParam() const {
+  return auditParam_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setAuditParam(const std::string &auditParam) {
+  auditParam_ = auditParam;
+  setParameter(std::string("AuditParam"), auditParam);
+}
+
+int CreateAndAnalyzeNetworkPathRequest::getTargetPort() const {
+  return targetPort_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setTargetPort(int targetPort) {
+  targetPort_ = targetPort;
+  setParameter(std::string("TargetPort"), std::to_string(targetPort));
+}
+
+std::string CreateAndAnalyzeNetworkPathRequest::getSourceId() const {
+  return sourceId_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setSourceId(const std::string &sourceId) {
+  sourceId_ = sourceId;
+  setParameter(std::string("SourceId"), sourceId);
+}
+
+std::string CreateAndAnalyzeNetworkPathRequest::getSourceIpAddress() const {
+  return sourceIpAddress_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setSourceIpAddress(const std::string &sourceIpAddress) {
+  sourceIpAddress_ = sourceIpAddress;
+  setParameter(std::string("SourceIpAddress"), sourceIpAddress);
+}
+
+bool CreateAndAnalyzeNetworkPathRequest::getUseMultiAccount() const {
+  return useMultiAccount_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setUseMultiAccount(bool useMultiAccount) {
+  useMultiAccount_ = useMultiAccount;
+  setParameter(std::string("UseMultiAccount"), useMultiAccount ? "true" : "false");
+}
+
+long CreateAndAnalyzeNetworkPathRequest::getTargetAliUid() const {
+  return targetAliUid_;
+}
+
+void CreateAndAnalyzeNetworkPathRequest::setTargetAliUid(long targetAliUid) {
+  targetAliUid_ = targetAliUid;
+  setParameter(std::string("TargetAliUid"), std::to_string(targetAliUid));
+}
+

nis/src/model/CreateAndAnalyzeNetworkPathResult.cc

@@ -0,0 +1,114 @@
+/*
+ * 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/nis/model/CreateAndAnalyzeNetworkPathResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nis;
+using namespace AlibabaCloud::Nis::Model;
+
+CreateAndAnalyzeNetworkPathResult::CreateAndAnalyzeNetworkPathResult() :
+	ServiceResult()
+{}
+
+CreateAndAnalyzeNetworkPathResult::CreateAndAnalyzeNetworkPathResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CreateAndAnalyzeNetworkPathResult::~CreateAndAnalyzeNetworkPathResult()
+{}
+
+void CreateAndAnalyzeNetworkPathResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["NetworkReachableAnalysisId"].isNull())
+		networkReachableAnalysisId_ = value["NetworkReachableAnalysisId"].asString();
+	if(!value["SourceId"].isNull())
+		sourceId_ = value["SourceId"].asString();
+	if(!value["TargetId"].isNull())
+		targetId_ = value["TargetId"].asString();
+	if(!value["SourceType"].isNull())
+		sourceType_ = value["SourceType"].asString();
+	if(!value["TargetType"].isNull())
+		targetType_ = value["TargetType"].asString();
+	if(!value["SourcePort"].isNull())
+		sourcePort_ = value["SourcePort"].asString();
+	if(!value["TargetPort"].isNull())
+		targetPort_ = value["TargetPort"].asString();
+	if(!value["Protocol"].isNull())
+		protocol_ = value["Protocol"].asString();
+	if(!value["SourceIpAddress"].isNull())
+		sourceIpAddress_ = value["SourceIpAddress"].asString();
+	if(!value["TargetIpAddress"].isNull())
+		targetIpAddress_ = value["TargetIpAddress"].asString();
+
+}
+
+std::string CreateAndAnalyzeNetworkPathResult::getTargetPort()const
+{
+	return targetPort_;
+}
+
+std::string CreateAndAnalyzeNetworkPathResult::getNetworkReachableAnalysisId()const
+{
+	return networkReachableAnalysisId_;
+}
+
+std::string CreateAndAnalyzeNetworkPathResult::getSourceId()const
+{
+	return sourceId_;
+}
+
+std::string CreateAndAnalyzeNetworkPathResult::getSourceType()const
+{
+	return sourceType_;
+}
+
+std::string CreateAndAnalyzeNetworkPathResult::getTargetType()const
+{
+	return targetType_;
+}
+
+std::string CreateAndAnalyzeNetworkPathResult::getSourcePort()const
+{
+	return sourcePort_;
+}
+
+std::string CreateAndAnalyzeNetworkPathResult::getProtocol()const
+{
+	return protocol_;
+}
+
+std::string CreateAndAnalyzeNetworkPathResult::getTargetId()const
+{
+	return targetId_;
+}
+
+std::string CreateAndAnalyzeNetworkPathResult::getSourceIpAddress()const
+{
+	return sourceIpAddress_;
+}
+
+std::string CreateAndAnalyzeNetworkPathResult::getTargetIpAddress()const
+{
+	return targetIpAddress_;
+}
+

nis/src/model/CreateNetworkPathRequest.cc

@@ -0,0 +1,227 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nis/model/CreateNetworkPathRequest.h>
+
+using AlibabaCloud::Nis::Model::CreateNetworkPathRequest;
+
+CreateNetworkPathRequest::CreateNetworkPathRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "CreateNetworkPath") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateNetworkPathRequest::~CreateNetworkPathRequest() {}
+
+long CreateNetworkPathRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateNetworkPathRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string CreateNetworkPathRequest::getTargetId() const {
+  return targetId_;
+}
+
+void CreateNetworkPathRequest::setTargetId(const std::string &targetId) {
+  targetId_ = targetId;
+  setParameter(std::string("TargetId"), targetId);
+}
+
+std::string CreateNetworkPathRequest::getTargetType() const {
+  return targetType_;
+}
+
+void CreateNetworkPathRequest::setTargetType(const std::string &targetType) {
+  targetType_ = targetType;
+  setParameter(std::string("TargetType"), targetType);
+}
+
+std::string CreateNetworkPathRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateNetworkPathRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::vector<CreateNetworkPathRequest::SystemTag> CreateNetworkPathRequest::getSystemTag() const {
+  return systemTag_;
+}
+
+void CreateNetworkPathRequest::setSystemTag(const std::vector<CreateNetworkPathRequest::SystemTag> &systemTag) {
+  systemTag_ = systemTag;
+  for(int dep1 = 0; dep1 != systemTag.size(); dep1++) {
+  auto systemTagObj = systemTag.at(dep1);
+  std::string systemTagObjStr = std::string("SystemTag") + "." + std::to_string(dep1 + 1);
+    setParameter(systemTagObjStr + ".Key", systemTagObj.key);
+    setParameter(systemTagObjStr + ".Value", systemTagObj.value);
+    setParameter(systemTagObjStr + ".Scope", systemTagObj.scope);
+  }
+}
+
+std::string CreateNetworkPathRequest::getTargetIpAddress() const {
+  return targetIpAddress_;
+}
+
+void CreateNetworkPathRequest::setTargetIpAddress(const std::string &targetIpAddress) {
+  targetIpAddress_ = targetIpAddress;
+  setParameter(std::string("TargetIpAddress"), targetIpAddress);
+}
+
+std::string CreateNetworkPathRequest::getNetworkPathName() const {
+  return networkPathName_;
+}
+
+void CreateNetworkPathRequest::setNetworkPathName(const std::string &networkPathName) {
+  networkPathName_ = networkPathName;
+  setParameter(std::string("NetworkPathName"), networkPathName);
+}
+
+int CreateNetworkPathRequest::getSourcePort() const {
+  return sourcePort_;
+}
+
+void CreateNetworkPathRequest::setSourcePort(int sourcePort) {
+  sourcePort_ = sourcePort;
+  setParameter(std::string("SourcePort"), std::to_string(sourcePort));
+}
+
+std::string CreateNetworkPathRequest::getResourceGroupId() const {
+  return resourceGroupId_;
+}
+
+void CreateNetworkPathRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
+}
+
+std::string CreateNetworkPathRequest::getProtocol() const {
+  return protocol_;
+}
+
+void CreateNetworkPathRequest::setProtocol(const std::string &protocol) {
+  protocol_ = protocol;
+  setParameter(std::string("Protocol"), protocol);
+}
+
+std::string CreateNetworkPathRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateNetworkPathRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+long CreateNetworkPathRequest::getSourceAliUid() const {
+  return sourceAliUid_;
+}
+
+void CreateNetworkPathRequest::setSourceAliUid(long sourceAliUid) {
+  sourceAliUid_ = sourceAliUid;
+  setParameter(std::string("SourceAliUid"), std::to_string(sourceAliUid));
+}
+
+std::string CreateNetworkPathRequest::getSourceType() const {
+  return sourceType_;
+}
+
+void CreateNetworkPathRequest::setSourceType(const std::string &sourceType) {
+  sourceType_ = sourceType;
+  setParameter(std::string("SourceType"), sourceType);
+}
+
+std::vector<CreateNetworkPathRequest::Tag> CreateNetworkPathRequest::getTag() const {
+  return tag_;
+}
+
+void CreateNetworkPathRequest::setTag(const std::vector<CreateNetworkPathRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+  }
+}
+
+int CreateNetworkPathRequest::getTargetPort() const {
+  return targetPort_;
+}
+
+void CreateNetworkPathRequest::setTargetPort(int targetPort) {
+  targetPort_ = targetPort;
+  setParameter(std::string("TargetPort"), std::to_string(targetPort));
+}
+
+std::string CreateNetworkPathRequest::getSourceId() const {
+  return sourceId_;
+}
+
+void CreateNetworkPathRequest::setSourceId(const std::string &sourceId) {
+  sourceId_ = sourceId;
+  setParameter(std::string("SourceId"), sourceId);
+}
+
+std::string CreateNetworkPathRequest::getSourceIpAddress() const {
+  return sourceIpAddress_;
+}
+
+void CreateNetworkPathRequest::setSourceIpAddress(const std::string &sourceIpAddress) {
+  sourceIpAddress_ = sourceIpAddress;
+  setParameter(std::string("SourceIpAddress"), sourceIpAddress);
+}
+
+bool CreateNetworkPathRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void CreateNetworkPathRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+bool CreateNetworkPathRequest::getUseMultiAccount() const {
+  return useMultiAccount_;
+}
+
+void CreateNetworkPathRequest::setUseMultiAccount(bool useMultiAccount) {
+  useMultiAccount_ = useMultiAccount;
+  setParameter(std::string("UseMultiAccount"), useMultiAccount ? "true" : "false");
+}
+
+std::string CreateNetworkPathRequest::getNetworkPathDescription() const {
+  return networkPathDescription_;
+}
+
+void CreateNetworkPathRequest::setNetworkPathDescription(const std::string &networkPathDescription) {
+  networkPathDescription_ = networkPathDescription;
+  setParameter(std::string("NetworkPathDescription"), networkPathDescription);
+}
+
+long CreateNetworkPathRequest::getTargetAliUid() const {
+  return targetAliUid_;
+}
+
+void CreateNetworkPathRequest::setTargetAliUid(long targetAliUid) {
+  targetAliUid_ = targetAliUid;
+  setParameter(std::string("TargetAliUid"), std::to_string(targetAliUid));
+}
+

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

nis/src/model/CreateNetworkReachableAnalysisRequest.cc

@@ -0,0 +1,110 @@
+/*
+ * 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/nis/model/CreateNetworkReachableAnalysisRequest.h>
+
+using AlibabaCloud::Nis::Model::CreateNetworkReachableAnalysisRequest;
+
+CreateNetworkReachableAnalysisRequest::CreateNetworkReachableAnalysisRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "CreateNetworkReachableAnalysis") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateNetworkReachableAnalysisRequest::~CreateNetworkReachableAnalysisRequest() {}
+
+long CreateNetworkReachableAnalysisRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateNetworkReachableAnalysisRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+bool CreateNetworkReachableAnalysisRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void CreateNetworkReachableAnalysisRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string CreateNetworkReachableAnalysisRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void CreateNetworkReachableAnalysisRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::vector<CreateNetworkReachableAnalysisRequest::SystemTag> CreateNetworkReachableAnalysisRequest::getSystemTag() const {
+  return systemTag_;
+}
+
+void CreateNetworkReachableAnalysisRequest::setSystemTag(const std::vector<CreateNetworkReachableAnalysisRequest::SystemTag> &systemTag) {
+  systemTag_ = systemTag;
+  for(int dep1 = 0; dep1 != systemTag.size(); dep1++) {
+  auto systemTagObj = systemTag.at(dep1);
+  std::string systemTagObjStr = std::string("SystemTag") + "." + std::to_string(dep1 + 1);
+    setParameter(systemTagObjStr + ".Key", systemTagObj.key);
+    setParameter(systemTagObjStr + ".Value", systemTagObj.value);
+    setParameter(systemTagObjStr + ".Scope", systemTagObj.scope);
+  }
+}
+
+std::string CreateNetworkReachableAnalysisRequest::getNetworkPathId() const {
+  return networkPathId_;
+}
+
+void CreateNetworkReachableAnalysisRequest::setNetworkPathId(const std::string &networkPathId) {
+  networkPathId_ = networkPathId;
+  setParameter(std::string("NetworkPathId"), networkPathId);
+}
+
+std::string CreateNetworkReachableAnalysisRequest::getRegionId() const {
+  return regionId_;
+}
+
+void CreateNetworkReachableAnalysisRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string CreateNetworkReachableAnalysisRequest::getAuditParam() const {
+  return auditParam_;
+}
+
+void CreateNetworkReachableAnalysisRequest::setAuditParam(const std::string &auditParam) {
+  auditParam_ = auditParam;
+  setParameter(std::string("AuditParam"), auditParam);
+}
+
+std::vector<CreateNetworkReachableAnalysisRequest::Tag> CreateNetworkReachableAnalysisRequest::getTag() const {
+  return tag_;
+}
+
+void CreateNetworkReachableAnalysisRequest::setTag(const std::vector<CreateNetworkReachableAnalysisRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+  }
+}
+

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

nis/src/model/DeleteNetworkPathRequest.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/nis/model/DeleteNetworkPathRequest.h>
+
+using AlibabaCloud::Nis::Model::DeleteNetworkPathRequest;
+
+DeleteNetworkPathRequest::DeleteNetworkPathRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "DeleteNetworkPath") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteNetworkPathRequest::~DeleteNetworkPathRequest() {}
+
+bool DeleteNetworkPathRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void DeleteNetworkPathRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string DeleteNetworkPathRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void DeleteNetworkPathRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::vector<DeleteNetworkPathRequest::std::string> DeleteNetworkPathRequest::getNetworkPathIds() const {
+  return networkPathIds_;
+}
+
+void DeleteNetworkPathRequest::setNetworkPathIds(const std::vector<DeleteNetworkPathRequest::std::string> &networkPathIds) {
+  networkPathIds_ = networkPathIds;
+  for(int dep1 = 0; dep1 != networkPathIds.size(); dep1++) {
+    setParameter(std::string("NetworkPathIds") + "." + std::to_string(dep1 + 1), networkPathIds[dep1]);
+  }
+}
+
+std::string DeleteNetworkPathRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteNetworkPathRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

nis/src/model/DeleteNetworkPathResult.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/nis/model/DeleteNetworkPathResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nis;
+using namespace AlibabaCloud::Nis::Model;
+
+DeleteNetworkPathResult::DeleteNetworkPathResult() :
+	ServiceResult()
+{}
+
+DeleteNetworkPathResult::DeleteNetworkPathResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteNetworkPathResult::~DeleteNetworkPathResult()
+{}
+
+void DeleteNetworkPathResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString() == "true";
+
+}
+
+bool DeleteNetworkPathResult::getData()const
+{
+	return data_;
+}
+

nis/src/model/DeleteNetworkReachableAnalysisRequest.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/nis/model/DeleteNetworkReachableAnalysisRequest.h>
+
+using AlibabaCloud::Nis::Model::DeleteNetworkReachableAnalysisRequest;
+
+DeleteNetworkReachableAnalysisRequest::DeleteNetworkReachableAnalysisRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "DeleteNetworkReachableAnalysis") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteNetworkReachableAnalysisRequest::~DeleteNetworkReachableAnalysisRequest() {}
+
+bool DeleteNetworkReachableAnalysisRequest::getDryRun() const {
+  return dryRun_;
+}
+
+void DeleteNetworkReachableAnalysisRequest::setDryRun(bool dryRun) {
+  dryRun_ = dryRun;
+  setParameter(std::string("DryRun"), dryRun ? "true" : "false");
+}
+
+std::string DeleteNetworkReachableAnalysisRequest::getClientToken() const {
+  return clientToken_;
+}
+
+void DeleteNetworkReachableAnalysisRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
+}
+
+std::string DeleteNetworkReachableAnalysisRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DeleteNetworkReachableAnalysisRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::vector<DeleteNetworkReachableAnalysisRequest::std::string> DeleteNetworkReachableAnalysisRequest::getNetworkReachableAnalysisIds() const {
+  return networkReachableAnalysisIds_;
+}
+
+void DeleteNetworkReachableAnalysisRequest::setNetworkReachableAnalysisIds(const std::vector<DeleteNetworkReachableAnalysisRequest::std::string> &networkReachableAnalysisIds) {
+  networkReachableAnalysisIds_ = networkReachableAnalysisIds;
+  for(int dep1 = 0; dep1 != networkReachableAnalysisIds.size(); dep1++) {
+    setParameter(std::string("NetworkReachableAnalysisIds") + "." + std::to_string(dep1 + 1), networkReachableAnalysisIds[dep1]);
+  }
+}
+

nis/src/model/DeleteNetworkReachableAnalysisResult.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/nis/model/DeleteNetworkReachableAnalysisResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nis;
+using namespace AlibabaCloud::Nis::Model;
+
+DeleteNetworkReachableAnalysisResult::DeleteNetworkReachableAnalysisResult() :
+	ServiceResult()
+{}
+
+DeleteNetworkReachableAnalysisResult::DeleteNetworkReachableAnalysisResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DeleteNetworkReachableAnalysisResult::~DeleteNetworkReachableAnalysisResult()
+{}
+
+void DeleteNetworkReachableAnalysisResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Data"].isNull())
+		data_ = value["Data"].asString() == "true";
+
+}
+
+bool DeleteNetworkReachableAnalysisResult::getData()const
+{
+	return data_;
+}
+

nis/src/model/GetInternetTupleRequest.cc

@@ -0,0 +1,228 @@
+/*
+ * 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/nis/model/GetInternetTupleRequest.h>
+
+using AlibabaCloud::Nis::Model::GetInternetTupleRequest;
+
+GetInternetTupleRequest::GetInternetTupleRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "GetInternetTuple") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetInternetTupleRequest::~GetInternetTupleRequest() {}
+
+std::string GetInternetTupleRequest::getOtherPort() const {
+  return otherPort_;
+}
+
+void GetInternetTupleRequest::setOtherPort(const std::string &otherPort) {
+  otherPort_ = otherPort;
+  setParameter(std::string("OtherPort"), otherPort);
+}
+
+std::string GetInternetTupleRequest::getCloudIsp() const {
+  return cloudIsp_;
+}
+
+void GetInternetTupleRequest::setCloudIsp(const std::string &cloudIsp) {
+  cloudIsp_ = cloudIsp;
+  setParameter(std::string("CloudIsp"), cloudIsp);
+}
+
+int GetInternetTupleRequest::getTopN() const {
+  return topN_;
+}
+
+void GetInternetTupleRequest::setTopN(int topN) {
+  topN_ = topN;
+  setParameter(std::string("TopN"), std::to_string(topN));
+}
+
+std::string GetInternetTupleRequest::getCloudPort() const {
+  return cloudPort_;
+}
+
+void GetInternetTupleRequest::setCloudPort(const std::string &cloudPort) {
+  cloudPort_ = cloudPort;
+  setParameter(std::string("CloudPort"), cloudPort);
+}
+
+std::string GetInternetTupleRequest::getProtocol() const {
+  return protocol_;
+}
+
+void GetInternetTupleRequest::setProtocol(const std::string &protocol) {
+  protocol_ = protocol;
+  setParameter(std::string("Protocol"), protocol);
+}
+
+std::string GetInternetTupleRequest::getOtherIp() const {
+  return otherIp_;
+}
+
+void GetInternetTupleRequest::setOtherIp(const std::string &otherIp) {
+  otherIp_ = otherIp;
+  setParameter(std::string("OtherIp"), otherIp);
+}
+
+std::vector<GetInternetTupleRequest::std::string> GetInternetTupleRequest::getInstanceList() const {
+  return instanceList_;
+}
+
+void GetInternetTupleRequest::setInstanceList(const std::vector<GetInternetTupleRequest::std::string> &instanceList) {
+  instanceList_ = instanceList;
+  for(int dep1 = 0; dep1 != instanceList.size(); dep1++) {
+    setParameter(std::string("InstanceList") + "." + std::to_string(dep1 + 1), instanceList[dep1]);
+  }
+}
+
+std::string GetInternetTupleRequest::getOrderBy() const {
+  return orderBy_;
+}
+
+void GetInternetTupleRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
+}
+
+std::string GetInternetTupleRequest::getSort() const {
+  return sort_;
+}
+
+void GetInternetTupleRequest::setSort(const std::string &sort) {
+  sort_ = sort;
+  setParameter(std::string("Sort"), sort);
+}
+
+bool GetInternetTupleRequest::getUseMultiAccount() const {
+  return useMultiAccount_;
+}
+
+void GetInternetTupleRequest::setUseMultiAccount(bool useMultiAccount) {
+  useMultiAccount_ = useMultiAccount;
+  setParameter(std::string("UseMultiAccount"), useMultiAccount ? "true" : "false");
+}
+
+std::string GetInternetTupleRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void GetInternetTupleRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setParameter(std::string("InstanceId"), instanceId);
+}
+
+int GetInternetTupleRequest::getTupleType() const {
+  return tupleType_;
+}
+
+void GetInternetTupleRequest::setTupleType(int tupleType) {
+  tupleType_ = tupleType;
+  setParameter(std::string("TupleType"), std::to_string(tupleType));
+}
+
+std::string GetInternetTupleRequest::getCloudIp() const {
+  return cloudIp_;
+}
+
+void GetInternetTupleRequest::setCloudIp(const std::string &cloudIp) {
+  cloudIp_ = cloudIp;
+  setParameter(std::string("CloudIp"), cloudIp);
+}
+
+std::vector<GetInternetTupleRequest::std::string> GetInternetTupleRequest::getCloudIpList() const {
+  return cloudIpList_;
+}
+
+void GetInternetTupleRequest::setCloudIpList(const std::vector<GetInternetTupleRequest::std::string> &cloudIpList) {
+  cloudIpList_ = cloudIpList;
+  for(int dep1 = 0; dep1 != cloudIpList.size(); dep1++) {
+    setParameter(std::string("CloudIpList") + "." + std::to_string(dep1 + 1), cloudIpList[dep1]);
+  }
+}
+
+std::string GetInternetTupleRequest::getOtherIsp() const {
+  return otherIsp_;
+}
+
+void GetInternetTupleRequest::setOtherIsp(const std::string &otherIsp) {
+  otherIsp_ = otherIsp;
+  setParameter(std::string("OtherIsp"), otherIsp);
+}
+
+std::string GetInternetTupleRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetInternetTupleRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetInternetTupleRequest::getOtherCountry() const {
+  return otherCountry_;
+}
+
+void GetInternetTupleRequest::setOtherCountry(const std::string &otherCountry) {
+  otherCountry_ = otherCountry;
+  setParameter(std::string("OtherCountry"), otherCountry);
+}
+
+std::string GetInternetTupleRequest::getDirection() const {
+  return direction_;
+}
+
+void GetInternetTupleRequest::setDirection(const std::string &direction) {
+  direction_ = direction;
+  setParameter(std::string("Direction"), direction);
+}
+
+long GetInternetTupleRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetInternetTupleRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+long GetInternetTupleRequest::getBeginTime() const {
+  return beginTime_;
+}
+
+void GetInternetTupleRequest::setBeginTime(long beginTime) {
+  beginTime_ = beginTime;
+  setParameter(std::string("BeginTime"), std::to_string(beginTime));
+}
+
+std::string GetInternetTupleRequest::getOtherCity() const {
+  return otherCity_;
+}
+
+void GetInternetTupleRequest::setOtherCity(const std::string &otherCity) {
+  otherCity_ = otherCity;
+  setParameter(std::string("OtherCity"), otherCity);
+}
+
+std::vector<long> GetInternetTupleRequest::getAccountIds() const {
+  return accountIds_;
+}
+
+void GetInternetTupleRequest::setAccountIds(const std::vector<long> &accountIds) {
+  accountIds_ = accountIds;
+}
+

nis/src/model/GetInternetTupleResult.cc

@@ -0,0 +1,121 @@
+/*
+ * 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/nis/model/GetInternetTupleResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nis;
+using namespace AlibabaCloud::Nis::Model;
+
+GetInternetTupleResult::GetInternetTupleResult() :
+	ServiceResult()
+{}
+
+GetInternetTupleResult::GetInternetTupleResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetInternetTupleResult::~GetInternetTupleResult()
+{}
+
+void GetInternetTupleResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["BeginTime"].isNull())
+			dataObject.beginTime = valueDataDataItem["BeginTime"].asString();
+		if(!valueDataDataItem["Direction"].isNull())
+			dataObject.direction = valueDataDataItem["Direction"].asString();
+		if(!valueDataDataItem["InstanceId"].isNull())
+			dataObject.instanceId = valueDataDataItem["InstanceId"].asString();
+		if(!valueDataDataItem["AccessRegion"].isNull())
+			dataObject.accessRegion = valueDataDataItem["AccessRegion"].asString();
+		if(!valueDataDataItem["CloudIp"].isNull())
+			dataObject.cloudIp = valueDataDataItem["CloudIp"].asString();
+		if(!valueDataDataItem["CloudPort"].isNull())
+			dataObject.cloudPort = valueDataDataItem["CloudPort"].asString();
+		if(!valueDataDataItem["OtherIp"].isNull())
+			dataObject.otherIp = valueDataDataItem["OtherIp"].asString();
+		if(!valueDataDataItem["OtherPort"].isNull())
+			dataObject.otherPort = valueDataDataItem["OtherPort"].asString();
+		if(!valueDataDataItem["Protocol"].isNull())
+			dataObject.protocol = valueDataDataItem["Protocol"].asString();
+		if(!valueDataDataItem["CloudCountry"].isNull())
+			dataObject.cloudCountry = valueDataDataItem["CloudCountry"].asString();
+		if(!valueDataDataItem["CloudProvince"].isNull())
+			dataObject.cloudProvince = valueDataDataItem["CloudProvince"].asString();
+		if(!valueDataDataItem["CloudCity"].isNull())
+			dataObject.cloudCity = valueDataDataItem["CloudCity"].asString();
+		if(!valueDataDataItem["CloudIsp"].isNull())
+			dataObject.cloudIsp = valueDataDataItem["CloudIsp"].asString();
+		if(!valueDataDataItem["CloudProduct"].isNull())
+			dataObject.cloudProduct = valueDataDataItem["CloudProduct"].asString();
+		if(!valueDataDataItem["OtherCountry"].isNull())
+			dataObject.otherCountry = valueDataDataItem["OtherCountry"].asString();
+		if(!valueDataDataItem["OtherProvince"].isNull())
+			dataObject.otherProvince = valueDataDataItem["OtherProvince"].asString();
+		if(!valueDataDataItem["OtherCity"].isNull())
+			dataObject.otherCity = valueDataDataItem["OtherCity"].asString();
+		if(!valueDataDataItem["OtherIsp"].isNull())
+			dataObject.otherIsp = valueDataDataItem["OtherIsp"].asString();
+		if(!valueDataDataItem["OtherProduct"].isNull())
+			dataObject.otherProduct = valueDataDataItem["OtherProduct"].asString();
+		if(!valueDataDataItem["Rtt"].isNull())
+			dataObject.rtt = valueDataDataItem["Rtt"].asString();
+		if(!valueDataDataItem["ByteCount"].isNull())
+			dataObject.byteCount = valueDataDataItem["ByteCount"].asString();
+		if(!valueDataDataItem["PacketCount"].isNull())
+			dataObject.packetCount = valueDataDataItem["PacketCount"].asString();
+		if(!valueDataDataItem["OutOrderCount"].isNull())
+			dataObject.outOrderCount = valueDataDataItem["OutOrderCount"].asString();
+		if(!valueDataDataItem["RetranCount"].isNull())
+			dataObject.retranCount = valueDataDataItem["RetranCount"].asString();
+		if(!valueDataDataItem["InByteCount"].isNull())
+			dataObject.inByteCount = valueDataDataItem["InByteCount"].asString();
+		if(!valueDataDataItem["OutByteCount"].isNull())
+			dataObject.outByteCount = valueDataDataItem["OutByteCount"].asString();
+		if(!valueDataDataItem["InPacketCount"].isNull())
+			dataObject.inPacketCount = valueDataDataItem["InPacketCount"].asString();
+		if(!valueDataDataItem["OutPacketCount"].isNull())
+			dataObject.outPacketCount = valueDataDataItem["OutPacketCount"].asString();
+		if(!valueDataDataItem["InOutOrderCount"].isNull())
+			dataObject.inOutOrderCount = valueDataDataItem["InOutOrderCount"].asString();
+		if(!valueDataDataItem["OutOutOrderCount"].isNull())
+			dataObject.outOutOrderCount = valueDataDataItem["OutOutOrderCount"].asString();
+		if(!valueDataDataItem["InRetranCount"].isNull())
+			dataObject.inRetranCount = valueDataDataItem["InRetranCount"].asString();
+		if(!valueDataDataItem["OutRetranCount"].isNull())
+			dataObject.outRetranCount = valueDataDataItem["OutRetranCount"].asString();
+		if(!valueDataDataItem["RetransmitRate"].isNull())
+			dataObject.retransmitRate = valueDataDataItem["RetransmitRate"].asString();
+		data_.push_back(dataObject);
+	}
+
+}
+
+std::vector<GetInternetTupleResult::DataItem> GetInternetTupleResult::getData()const
+{
+	return data_;
+}
+

nis/src/model/GetNatTopNRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nis/model/GetNatTopNRequest.h>
+
+using AlibabaCloud::Nis::Model::GetNatTopNRequest;
+
+GetNatTopNRequest::GetNatTopNRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "GetNatTopN") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetNatTopNRequest::~GetNatTopNRequest() {}
+
+std::string GetNatTopNRequest::getIp() const {
+  return ip_;
+}
+
+void GetNatTopNRequest::setIp(const std::string &ip) {
+  ip_ = ip;
+  setParameter(std::string("Ip"), ip);
+}
+
+long GetNatTopNRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetNatTopNRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+std::string GetNatTopNRequest::getOrderBy() const {
+  return orderBy_;
+}
+
+void GetNatTopNRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
+}
+
+long GetNatTopNRequest::getBeginTime() const {
+  return beginTime_;
+}
+
+void GetNatTopNRequest::setBeginTime(long beginTime) {
+  beginTime_ = beginTime;
+  setParameter(std::string("BeginTime"), std::to_string(beginTime));
+}
+
+int GetNatTopNRequest::getTopN() const {
+  return topN_;
+}
+
+void GetNatTopNRequest::setTopN(int topN) {
+  topN_ = topN;
+  setParameter(std::string("TopN"), std::to_string(topN));
+}
+
+std::string GetNatTopNRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetNatTopNRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetNatTopNRequest::getNatGatewayId() const {
+  return natGatewayId_;
+}
+
+void GetNatTopNRequest::setNatGatewayId(const std::string &natGatewayId) {
+  natGatewayId_ = natGatewayId;
+  setParameter(std::string("NatGatewayId"), natGatewayId);
+}
+

nis/src/model/GetNatTopNResult.cc

@@ -0,0 +1,80 @@
+/*
+ * 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/nis/model/GetNatTopNResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nis;
+using namespace AlibabaCloud::Nis::Model;
+
+GetNatTopNResult::GetNatTopNResult() :
+	ServiceResult()
+{}
+
+GetNatTopNResult::GetNatTopNResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetNatTopNResult::~GetNatTopNResult()
+{}
+
+void GetNatTopNResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allNatGatewayTopNNode = value["NatGatewayTopN"]["NatGatewayTopNItem"];
+	for (auto valueNatGatewayTopNNatGatewayTopNItem : allNatGatewayTopNNode)
+	{
+		NatGatewayTopNItem natGatewayTopNObject;
+		if(!valueNatGatewayTopNNatGatewayTopNItem["Ip"].isNull())
+			natGatewayTopNObject.ip = valueNatGatewayTopNNatGatewayTopNItem["Ip"].asString();
+		if(!valueNatGatewayTopNNatGatewayTopNItem["InBps"].isNull())
+			natGatewayTopNObject.inBps = std::stof(valueNatGatewayTopNNatGatewayTopNItem["InBps"].asString());
+		if(!valueNatGatewayTopNNatGatewayTopNItem["OutBps"].isNull())
+			natGatewayTopNObject.outBps = std::stof(valueNatGatewayTopNNatGatewayTopNItem["OutBps"].asString());
+		if(!valueNatGatewayTopNNatGatewayTopNItem["InPps"].isNull())
+			natGatewayTopNObject.inPps = std::stof(valueNatGatewayTopNNatGatewayTopNItem["InPps"].asString());
+		if(!valueNatGatewayTopNNatGatewayTopNItem["OutPps"].isNull())
+			natGatewayTopNObject.outPps = std::stof(valueNatGatewayTopNNatGatewayTopNItem["OutPps"].asString());
+		if(!valueNatGatewayTopNNatGatewayTopNItem["InFlowPerMinute"].isNull())
+			natGatewayTopNObject.inFlowPerMinute = std::stof(valueNatGatewayTopNNatGatewayTopNItem["InFlowPerMinute"].asString());
+		if(!valueNatGatewayTopNNatGatewayTopNItem["OutFlowPerMinute"].isNull())
+			natGatewayTopNObject.outFlowPerMinute = std::stof(valueNatGatewayTopNNatGatewayTopNItem["OutFlowPerMinute"].asString());
+		if(!valueNatGatewayTopNNatGatewayTopNItem["NewSessionPerSecond"].isNull())
+			natGatewayTopNObject.newSessionPerSecond = std::stof(valueNatGatewayTopNNatGatewayTopNItem["NewSessionPerSecond"].asString());
+		if(!valueNatGatewayTopNNatGatewayTopNItem["ActiveSessionCount"].isNull())
+			natGatewayTopNObject.activeSessionCount = std::stof(valueNatGatewayTopNNatGatewayTopNItem["ActiveSessionCount"].asString());
+		natGatewayTopN_.push_back(natGatewayTopNObject);
+	}
+	if(!value["IsTopNOpen"].isNull())
+		isTopNOpen_ = value["IsTopNOpen"].asString() == "true";
+
+}
+
+std::vector<GetNatTopNResult::NatGatewayTopNItem> GetNatTopNResult::getNatGatewayTopN()const
+{
+	return natGatewayTopN_;
+}
+
+bool GetNatTopNResult::getIsTopNOpen()const
+{
+	return isTopNOpen_;
+}
+

nis/src/model/GetNetworkReachableAnalysisRequest.cc

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nis/model/GetNetworkReachableAnalysisRequest.h>
+
+using AlibabaCloud::Nis::Model::GetNetworkReachableAnalysisRequest;
+
+GetNetworkReachableAnalysisRequest::GetNetworkReachableAnalysisRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "GetNetworkReachableAnalysis") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetNetworkReachableAnalysisRequest::~GetNetworkReachableAnalysisRequest() {}
+
+std::string GetNetworkReachableAnalysisRequest::getNetworkReachableAnalysisId() const {
+  return networkReachableAnalysisId_;
+}
+
+void GetNetworkReachableAnalysisRequest::setNetworkReachableAnalysisId(const std::string &networkReachableAnalysisId) {
+  networkReachableAnalysisId_ = networkReachableAnalysisId;
+  setParameter(std::string("NetworkReachableAnalysisId"), networkReachableAnalysisId);
+}
+
+std::string GetNetworkReachableAnalysisRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetNetworkReachableAnalysisRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+

nis/src/model/GetNetworkReachableAnalysisResult.cc

@@ -0,0 +1,100 @@
+/*
+ * 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/nis/model/GetNetworkReachableAnalysisResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nis;
+using namespace AlibabaCloud::Nis::Model;
+
+GetNetworkReachableAnalysisResult::GetNetworkReachableAnalysisResult() :
+	ServiceResult()
+{}
+
+GetNetworkReachableAnalysisResult::GetNetworkReachableAnalysisResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetNetworkReachableAnalysisResult::~GetNetworkReachableAnalysisResult()
+{}
+
+void GetNetworkReachableAnalysisResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["NetworkPathId"].isNull())
+		networkPathId_ = value["NetworkPathId"].asString();
+	if(!value["NetworkReachableAnalysisId"].isNull())
+		networkReachableAnalysisId_ = value["NetworkReachableAnalysisId"].asString();
+	if(!value["NetworkReachableAnalysisStatus"].isNull())
+		networkReachableAnalysisStatus_ = value["NetworkReachableAnalysisStatus"].asString();
+	if(!value["NetworkReachableAnalysisResult"].isNull())
+		networkReachableAnalysisResult_ = value["NetworkReachableAnalysisResult"].asString();
+	if(!value["Reachable"].isNull())
+		reachable_ = value["Reachable"].asString() == "true";
+	if(!value["CreateTime"].isNull())
+		createTime_ = value["CreateTime"].asString();
+	if(!value["AliUid"].isNull())
+		aliUid_ = std::stol(value["AliUid"].asString());
+	if(!value["NetworkPathParameter"].isNull())
+		networkPathParameter_ = value["NetworkPathParameter"].asString();
+
+}
+
+std::string GetNetworkReachableAnalysisResult::getNetworkReachableAnalysisId()const
+{
+	return networkReachableAnalysisId_;
+}
+
+std::string GetNetworkReachableAnalysisResult::getCreateTime()const
+{
+	return createTime_;
+}
+
+bool GetNetworkReachableAnalysisResult::getReachable()const
+{
+	return reachable_;
+}
+
+std::string GetNetworkReachableAnalysisResult::getNetworkPathId()const
+{
+	return networkPathId_;
+}
+
+std::string GetNetworkReachableAnalysisResult::getNetworkReachableAnalysisResult()const
+{
+	return networkReachableAnalysisResult_;
+}
+
+std::string GetNetworkReachableAnalysisResult::getNetworkReachableAnalysisStatus()const
+{
+	return networkReachableAnalysisStatus_;
+}
+
+long GetNetworkReachableAnalysisResult::getAliUid()const
+{
+	return aliUid_;
+}
+
+std::string GetNetworkReachableAnalysisResult::getNetworkPathParameter()const
+{
+	return networkPathParameter_;
+}
+

nis/src/model/GetNisNetworkMetricsRequest.cc

@@ -0,0 +1,110 @@
+/*
+ * 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/nis/model/GetNisNetworkMetricsRequest.h>
+
+using AlibabaCloud::Nis::Model::GetNisNetworkMetricsRequest;
+
+GetNisNetworkMetricsRequest::GetNisNetworkMetricsRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "GetNisNetworkMetrics") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetNisNetworkMetricsRequest::~GetNisNetworkMetricsRequest() {}
+
+bool GetNisNetworkMetricsRequest::getUseCrossAccount() const {
+  return useCrossAccount_;
+}
+
+void GetNisNetworkMetricsRequest::setUseCrossAccount(bool useCrossAccount) {
+  useCrossAccount_ = useCrossAccount;
+  setParameter(std::string("UseCrossAccount"), useCrossAccount ? "true" : "false");
+}
+
+std::string GetNisNetworkMetricsRequest::getScanBy() const {
+  return scanBy_;
+}
+
+void GetNisNetworkMetricsRequest::setScanBy(const std::string &scanBy) {
+  scanBy_ = scanBy;
+  setParameter(std::string("ScanBy"), scanBy);
+}
+
+std::string GetNisNetworkMetricsRequest::getMetricName() const {
+  return metricName_;
+}
+
+void GetNisNetworkMetricsRequest::setMetricName(const std::string &metricName) {
+  metricName_ = metricName;
+  setParameter(std::string("MetricName"), metricName);
+}
+
+long GetNisNetworkMetricsRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetNisNetworkMetricsRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+long GetNisNetworkMetricsRequest::getBeginTime() const {
+  return beginTime_;
+}
+
+void GetNisNetworkMetricsRequest::setBeginTime(long beginTime) {
+  beginTime_ = beginTime;
+  setParameter(std::string("BeginTime"), std::to_string(beginTime));
+}
+
+std::string GetNisNetworkMetricsRequest::getResourceType() const {
+  return resourceType_;
+}
+
+void GetNisNetworkMetricsRequest::setResourceType(const std::string &resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), resourceType);
+}
+
+std::string GetNisNetworkMetricsRequest::getRegionNo() const {
+  return regionNo_;
+}
+
+void GetNisNetworkMetricsRequest::setRegionNo(const std::string &regionNo) {
+  regionNo_ = regionNo;
+  setParameter(std::string("RegionNo"), regionNo);
+}
+
+std::vector<std::string> GetNisNetworkMetricsRequest::getAccountIds() const {
+  return accountIds_;
+}
+
+void GetNisNetworkMetricsRequest::setAccountIds(const std::vector<std::string> &accountIds) {
+  accountIds_ = accountIds;
+}
+
+std::vector<GetNisNetworkMetricsRequest::Dimensions> GetNisNetworkMetricsRequest::getDimensions() const {
+  return dimensions_;
+}
+
+void GetNisNetworkMetricsRequest::setDimensions(const std::vector<GetNisNetworkMetricsRequest::Dimensions> &dimensions) {
+  dimensions_ = dimensions;
+  for(int dep1 = 0; dep1 != dimensions.size(); dep1++) {
+    setParameter(std::string("Dimensions") + "." + std::to_string(dep1 + 1) + ".Name", dimensions[dep1].name);
+    setParameter(std::string("Dimensions") + "." + std::to_string(dep1 + 1) + ".Value", dimensions[dep1].value);
+  }
+}
+

nis/src/model/GetNisNetworkMetricsResult.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/nis/model/GetNisNetworkMetricsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nis;
+using namespace AlibabaCloud::Nis::Model;
+
+GetNisNetworkMetricsResult::GetNisNetworkMetricsResult() :
+	ServiceResult()
+{}
+
+GetNisNetworkMetricsResult::GetNisNetworkMetricsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetNisNetworkMetricsResult::~GetNisNetworkMetricsResult()
+{}
+
+void GetNisNetworkMetricsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["Unit"].isNull())
+		data_.unit = dataNode["Unit"].asString();
+	auto allMetricsNode = dataNode["Metrics"]["MetricsItem"];
+	for (auto dataNodeMetricsMetricsItem : allMetricsNode)
+	{
+		Data::MetricsItem metricsItemObject;
+		if(!dataNodeMetricsMetricsItem["TimeStamp"].isNull())
+			metricsItemObject.timeStamp = std::stol(dataNodeMetricsMetricsItem["TimeStamp"].asString());
+		if(!dataNodeMetricsMetricsItem["Value"].isNull())
+			metricsItemObject.value = dataNodeMetricsMetricsItem["Value"].asString();
+		data_.metrics.push_back(metricsItemObject);
+	}
+
+}
+
+GetNisNetworkMetricsResult::Data GetNisNetworkMetricsResult::getData()const
+{
+	return data_;
+}
+

nis/src/model/GetNisNetworkRankingRequest.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/nis/model/GetNisNetworkRankingRequest.h>
+
+using AlibabaCloud::Nis::Model::GetNisNetworkRankingRequest;
+
+GetNisNetworkRankingRequest::GetNisNetworkRankingRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "GetNisNetworkRanking") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetNisNetworkRankingRequest::~GetNisNetworkRankingRequest() {}
+
+bool GetNisNetworkRankingRequest::getUseCrossAccount() const {
+  return useCrossAccount_;
+}
+
+void GetNisNetworkRankingRequest::setUseCrossAccount(bool useCrossAccount) {
+  useCrossAccount_ = useCrossAccount;
+  setParameter(std::string("UseCrossAccount"), useCrossAccount ? "true" : "false");
+}
+
+int GetNisNetworkRankingRequest::getTopN() const {
+  return topN_;
+}
+
+void GetNisNetworkRankingRequest::setTopN(int topN) {
+  topN_ = topN;
+  setParameter(std::string("TopN"), std::to_string(topN));
+}
+
+std::string GetNisNetworkRankingRequest::getDirection() const {
+  return direction_;
+}
+
+void GetNisNetworkRankingRequest::setDirection(const std::string &direction) {
+  direction_ = direction;
+  setParameter(std::string("Direction"), direction);
+}
+
+std::string GetNisNetworkRankingRequest::getOrderBy() const {
+  return orderBy_;
+}
+
+void GetNisNetworkRankingRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
+}
+
+long GetNisNetworkRankingRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetNisNetworkRankingRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+long GetNisNetworkRankingRequest::getBeginTime() const {
+  return beginTime_;
+}
+
+void GetNisNetworkRankingRequest::setBeginTime(long beginTime) {
+  beginTime_ = beginTime;
+  setParameter(std::string("BeginTime"), std::to_string(beginTime));
+}
+
+std::string GetNisNetworkRankingRequest::getGroupBy() const {
+  return groupBy_;
+}
+
+void GetNisNetworkRankingRequest::setGroupBy(const std::string &groupBy) {
+  groupBy_ = groupBy;
+  setParameter(std::string("GroupBy"), groupBy);
+}
+
+std::string GetNisNetworkRankingRequest::getSort() const {
+  return sort_;
+}
+
+void GetNisNetworkRankingRequest::setSort(const std::string &sort) {
+  sort_ = sort;
+  setParameter(std::string("Sort"), sort);
+}
+
+std::string GetNisNetworkRankingRequest::getResourceType() const {
+  return resourceType_;
+}
+
+void GetNisNetworkRankingRequest::setResourceType(const std::string &resourceType) {
+  resourceType_ = resourceType;
+  setParameter(std::string("ResourceType"), resourceType);
+}
+
+std::string GetNisNetworkRankingRequest::getRegionNo() const {
+  return regionNo_;
+}
+
+void GetNisNetworkRankingRequest::setRegionNo(const std::string &regionNo) {
+  regionNo_ = regionNo;
+  setParameter(std::string("RegionNo"), regionNo);
+}
+
+std::vector<GetNisNetworkRankingRequest::Filter> GetNisNetworkRankingRequest::getFilter() const {
+  return filter_;
+}
+
+void GetNisNetworkRankingRequest::setFilter(const std::vector<GetNisNetworkRankingRequest::Filter> &filter) {
+  filter_ = filter;
+  for(int dep1 = 0; dep1 != filter.size(); dep1++) {
+    setParameter(std::string("Filter") + "." + std::to_string(dep1 + 1) + ".Name", filter[dep1].name);
+    setParameter(std::string("Filter") + "." + std::to_string(dep1 + 1) + ".Value", filter[dep1].value);
+  }
+}
+
+std::vector<std::string> GetNisNetworkRankingRequest::getAccountIds() const {
+  return accountIds_;
+}
+
+void GetNisNetworkRankingRequest::setAccountIds(const std::vector<std::string> &accountIds) {
+  accountIds_ = accountIds;
+}
+

nis/src/model/GetNisNetworkRankingResult.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/nis/model/GetNisNetworkRankingResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nis;
+using namespace AlibabaCloud::Nis::Model;
+
+GetNisNetworkRankingResult::GetNisNetworkRankingResult() :
+	ServiceResult()
+{}
+
+GetNisNetworkRankingResult::GetNisNetworkRankingResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetNisNetworkRankingResult::~GetNisNetworkRankingResult()
+{}
+
+void GetNisNetworkRankingResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["Rankings"];
+	for (auto valueDataRankings : allDataNode)
+	{
+		Rankings dataObject;
+		if(!valueDataRankings["RegionNo"].isNull())
+			dataObject.regionNo = valueDataRankings["RegionNo"].asString();
+		if(!valueDataRankings["InstanceId"].isNull())
+			dataObject.instanceId = valueDataRankings["InstanceId"].asString();
+		if(!valueDataRankings["BandwidthPackageId"].isNull())
+			dataObject.bandwidthPackageId = valueDataRankings["BandwidthPackageId"].asString();
+		if(!valueDataRankings["SourceIp"].isNull())
+			dataObject.sourceIp = valueDataRankings["SourceIp"].asString();
+		if(!valueDataRankings["SourcePort"].isNull())
+			dataObject.sourcePort = valueDataRankings["SourcePort"].asString();
+		if(!valueDataRankings["SourceIsp"].isNull())
+			dataObject.sourceIsp = valueDataRankings["SourceIsp"].asString();
+		if(!valueDataRankings["DestinationIp"].isNull())
+			dataObject.destinationIp = valueDataRankings["DestinationIp"].asString();
+		if(!valueDataRankings["DestinationPort"].isNull())
+			dataObject.destinationPort = valueDataRankings["DestinationPort"].asString();
+		if(!valueDataRankings["DestinationIsp"].isNull())
+			dataObject.destinationIsp = valueDataRankings["DestinationIsp"].asString();
+		if(!valueDataRankings["Protocol"].isNull())
+			dataObject.protocol = valueDataRankings["Protocol"].asString();
+		if(!valueDataRankings["Country"].isNull())
+			dataObject.country = valueDataRankings["Country"].asString();
+		if(!valueDataRankings["Province"].isNull())
+			dataObject.province = valueDataRankings["Province"].asString();
+		if(!valueDataRankings["City"].isNull())
+			dataObject.city = valueDataRankings["City"].asString();
+		if(!valueDataRankings["Isp"].isNull())
+			dataObject.isp = valueDataRankings["Isp"].asString();
+		if(!valueDataRankings["Asn"].isNull())
+			dataObject.asn = valueDataRankings["Asn"].asString();
+		if(!valueDataRankings["IP"].isNull())
+			dataObject.iP = valueDataRankings["IP"].asString();
+		if(!valueDataRankings["DestinationRegionNo"].isNull())
+			dataObject.destinationRegionNo = valueDataRankings["DestinationRegionNo"].asString();
+		if(!valueDataRankings["VbrId"].isNull())
+			dataObject.vbrId = valueDataRankings["VbrId"].asString();
+		if(!valueDataRankings["AttachmentId"].isNull())
+			dataObject.attachmentId = valueDataRankings["AttachmentId"].asString();
+		if(!valueDataRankings["SourceZone"].isNull())
+			dataObject.sourceZone = valueDataRankings["SourceZone"].asString();
+		if(!valueDataRankings["DestinationZone"].isNull())
+			dataObject.destinationZone = valueDataRankings["DestinationZone"].asString();
+		if(!valueDataRankings["ByteCount"].isNull())
+			dataObject.byteCount = valueDataRankings["ByteCount"].asString();
+		if(!valueDataRankings["PacketCount"].isNull())
+			dataObject.packetCount = valueDataRankings["PacketCount"].asString();
+		if(!valueDataRankings["RTT"].isNull())
+			dataObject.rTT = valueDataRankings["RTT"].asString();
+		if(!valueDataRankings["RetransmitRate"].isNull())
+			dataObject.retransmitRate = valueDataRankings["RetransmitRate"].asString();
+		if(!valueDataRankings["InBps"].isNull())
+			dataObject.inBps = valueDataRankings["InBps"].asString();
+		if(!valueDataRankings["InPps"].isNull())
+			dataObject.inPps = valueDataRankings["InPps"].asString();
+		if(!valueDataRankings["OutBps"].isNull())
+			dataObject.outBps = valueDataRankings["OutBps"].asString();
+		if(!valueDataRankings["OutPps"].isNull())
+			dataObject.outPps = valueDataRankings["OutPps"].asString();
+		if(!valueDataRankings["NewSessionPerSecond"].isNull())
+			dataObject.newSessionPerSecond = valueDataRankings["NewSessionPerSecond"].asString();
+		if(!valueDataRankings["ActiveSessionCount"].isNull())
+			dataObject.activeSessionCount = valueDataRankings["ActiveSessionCount"].asString();
+		data_.push_back(dataObject);
+	}
+
+}
+
+std::vector<GetNisNetworkRankingResult::Rankings> GetNisNetworkRankingResult::getData()const
+{
+	return data_;
+}
+

nis/src/model/GetTransitRouterFlowTopNRequest.cc

@@ -0,0 +1,191 @@
+/*
+ * 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/nis/model/GetTransitRouterFlowTopNRequest.h>
+
+using AlibabaCloud::Nis::Model::GetTransitRouterFlowTopNRequest;
+
+GetTransitRouterFlowTopNRequest::GetTransitRouterFlowTopNRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "GetTransitRouterFlowTopN") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetTransitRouterFlowTopNRequest::~GetTransitRouterFlowTopNRequest() {}
+
+std::string GetTransitRouterFlowTopNRequest::getOtherPort() const {
+  return otherPort_;
+}
+
+void GetTransitRouterFlowTopNRequest::setOtherPort(const std::string &otherPort) {
+  otherPort_ = otherPort;
+  setParameter(std::string("OtherPort"), otherPort);
+}
+
+int GetTransitRouterFlowTopNRequest::getTopN() const {
+  return topN_;
+}
+
+void GetTransitRouterFlowTopNRequest::setTopN(int topN) {
+  topN_ = topN;
+  setParameter(std::string("TopN"), std::to_string(topN));
+}
+
+std::string GetTransitRouterFlowTopNRequest::getProtocol() const {
+  return protocol_;
+}
+
+void GetTransitRouterFlowTopNRequest::setProtocol(const std::string &protocol) {
+  protocol_ = protocol;
+  setParameter(std::string("Protocol"), protocol);
+}
+
+std::string GetTransitRouterFlowTopNRequest::getThisIp() const {
+  return thisIp_;
+}
+
+void GetTransitRouterFlowTopNRequest::setThisIp(const std::string &thisIp) {
+  thisIp_ = thisIp;
+  setParameter(std::string("ThisIp"), thisIp);
+}
+
+std::string GetTransitRouterFlowTopNRequest::getOtherIp() const {
+  return otherIp_;
+}
+
+void GetTransitRouterFlowTopNRequest::setOtherIp(const std::string &otherIp) {
+  otherIp_ = otherIp;
+  setParameter(std::string("OtherIp"), otherIp);
+}
+
+std::string GetTransitRouterFlowTopNRequest::getBandwithPackageId() const {
+  return bandwithPackageId_;
+}
+
+void GetTransitRouterFlowTopNRequest::setBandwithPackageId(const std::string &bandwithPackageId) {
+  bandwithPackageId_ = bandwithPackageId;
+  setParameter(std::string("BandwithPackageId"), bandwithPackageId);
+}
+
+std::string GetTransitRouterFlowTopNRequest::getOrderBy() const {
+  return orderBy_;
+}
+
+void GetTransitRouterFlowTopNRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
+}
+
+std::string GetTransitRouterFlowTopNRequest::getSort() const {
+  return sort_;
+}
+
+void GetTransitRouterFlowTopNRequest::setSort(const std::string &sort) {
+  sort_ = sort;
+  setParameter(std::string("Sort"), sort);
+}
+
+bool GetTransitRouterFlowTopNRequest::getUseMultiAccount() const {
+  return useMultiAccount_;
+}
+
+void GetTransitRouterFlowTopNRequest::setUseMultiAccount(bool useMultiAccount) {
+  useMultiAccount_ = useMultiAccount;
+  setParameter(std::string("UseMultiAccount"), useMultiAccount ? "true" : "false");
+}
+
+std::string GetTransitRouterFlowTopNRequest::getThisRegion() const {
+  return thisRegion_;
+}
+
+void GetTransitRouterFlowTopNRequest::setThisRegion(const std::string &thisRegion) {
+  thisRegion_ = thisRegion;
+  setParameter(std::string("ThisRegion"), thisRegion);
+}
+
+std::string GetTransitRouterFlowTopNRequest::getCenId() const {
+  return cenId_;
+}
+
+void GetTransitRouterFlowTopNRequest::setCenId(const std::string &cenId) {
+  cenId_ = cenId;
+  setParameter(std::string("CenId"), cenId);
+}
+
+std::string GetTransitRouterFlowTopNRequest::getThisPort() const {
+  return thisPort_;
+}
+
+void GetTransitRouterFlowTopNRequest::setThisPort(const std::string &thisPort) {
+  thisPort_ = thisPort;
+  setParameter(std::string("ThisPort"), thisPort);
+}
+
+std::string GetTransitRouterFlowTopNRequest::getDirection() const {
+  return direction_;
+}
+
+void GetTransitRouterFlowTopNRequest::setDirection(const std::string &direction) {
+  direction_ = direction;
+  setParameter(std::string("Direction"), direction);
+}
+
+std::string GetTransitRouterFlowTopNRequest::getOtherRegion() const {
+  return otherRegion_;
+}
+
+void GetTransitRouterFlowTopNRequest::setOtherRegion(const std::string &otherRegion) {
+  otherRegion_ = otherRegion;
+  setParameter(std::string("OtherRegion"), otherRegion);
+}
+
+long GetTransitRouterFlowTopNRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetTransitRouterFlowTopNRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+long GetTransitRouterFlowTopNRequest::getBeginTime() const {
+  return beginTime_;
+}
+
+void GetTransitRouterFlowTopNRequest::setBeginTime(long beginTime) {
+  beginTime_ = beginTime;
+  setParameter(std::string("BeginTime"), std::to_string(beginTime));
+}
+
+std::string GetTransitRouterFlowTopNRequest::getGroupBy() const {
+  return groupBy_;
+}
+
+void GetTransitRouterFlowTopNRequest::setGroupBy(const std::string &groupBy) {
+  groupBy_ = groupBy;
+  setParameter(std::string("GroupBy"), groupBy);
+}
+
+std::vector<GetTransitRouterFlowTopNRequest::long> GetTransitRouterFlowTopNRequest::getAccountIds() const {
+  return accountIds_;
+}
+
+void GetTransitRouterFlowTopNRequest::setAccountIds(const std::vector<GetTransitRouterFlowTopNRequest::long> &accountIds) {
+  accountIds_ = accountIds;
+  for(int dep1 = 0; dep1 != accountIds.size(); dep1++) {
+    setParameter(std::string("AccountIds") + "." + std::to_string(dep1 + 1), std::to_string(accountIds[dep1]));
+  }
+}
+

nis/src/model/GetTransitRouterFlowTopNResult.cc

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nis/model/GetTransitRouterFlowTopNResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nis;
+using namespace AlibabaCloud::Nis::Model;
+
+GetTransitRouterFlowTopNResult::GetTransitRouterFlowTopNResult() :
+	ServiceResult()
+{}
+
+GetTransitRouterFlowTopNResult::GetTransitRouterFlowTopNResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetTransitRouterFlowTopNResult::~GetTransitRouterFlowTopNResult()
+{}
+
+void GetTransitRouterFlowTopNResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allTransitRouterFlowTopNNode = value["TransitRouterFlowTopN"]["TrFlowlogTopN"];
+	for (auto valueTransitRouterFlowTopNTrFlowlogTopN : allTransitRouterFlowTopNNode)
+	{
+		TrFlowlogTopN transitRouterFlowTopNObject;
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["AccountId"].isNull())
+			transitRouterFlowTopNObject.accountId = valueTransitRouterFlowTopNTrFlowlogTopN["AccountId"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["CenId"].isNull())
+			transitRouterFlowTopNObject.cenId = valueTransitRouterFlowTopNTrFlowlogTopN["CenId"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["ThisRegion"].isNull())
+			transitRouterFlowTopNObject.thisRegion = valueTransitRouterFlowTopNTrFlowlogTopN["ThisRegion"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["ThisIp"].isNull())
+			transitRouterFlowTopNObject.thisIp = valueTransitRouterFlowTopNTrFlowlogTopN["ThisIp"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["ThisPort"].isNull())
+			transitRouterFlowTopNObject.thisPort = valueTransitRouterFlowTopNTrFlowlogTopN["ThisPort"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["OtherRegion"].isNull())
+			transitRouterFlowTopNObject.otherRegion = valueTransitRouterFlowTopNTrFlowlogTopN["OtherRegion"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["OtherIp"].isNull())
+			transitRouterFlowTopNObject.otherIp = valueTransitRouterFlowTopNTrFlowlogTopN["OtherIp"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["OtherPort"].isNull())
+			transitRouterFlowTopNObject.otherPort = valueTransitRouterFlowTopNTrFlowlogTopN["OtherPort"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["Protocol"].isNull())
+			transitRouterFlowTopNObject.protocol = valueTransitRouterFlowTopNTrFlowlogTopN["Protocol"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["StartTime"].isNull())
+			transitRouterFlowTopNObject.startTime = valueTransitRouterFlowTopNTrFlowlogTopN["StartTime"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["EndTime"].isNull())
+			transitRouterFlowTopNObject.endTime = valueTransitRouterFlowTopNTrFlowlogTopN["EndTime"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["Packets"].isNull())
+			transitRouterFlowTopNObject.packets = valueTransitRouterFlowTopNTrFlowlogTopN["Packets"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["Bytes"].isNull())
+			transitRouterFlowTopNObject.bytes = valueTransitRouterFlowTopNTrFlowlogTopN["Bytes"].asString();
+		if(!valueTransitRouterFlowTopNTrFlowlogTopN["BandwithPackageId"].isNull())
+			transitRouterFlowTopNObject.bandwithPackageId = valueTransitRouterFlowTopNTrFlowlogTopN["BandwithPackageId"].asString();
+		transitRouterFlowTopN_.push_back(transitRouterFlowTopNObject);
+	}
+
+}
+
+std::vector<GetTransitRouterFlowTopNResult::TrFlowlogTopN> GetTransitRouterFlowTopNResult::getTransitRouterFlowTopN()const
+{
+	return transitRouterFlowTopN_;
+}
+

nis/src/model/GetVbrFlowTopNRequest.cc

@@ -0,0 +1,191 @@
+/*
+ * 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/nis/model/GetVbrFlowTopNRequest.h>
+
+using AlibabaCloud::Nis::Model::GetVbrFlowTopNRequest;
+
+GetVbrFlowTopNRequest::GetVbrFlowTopNRequest()
+    : RpcServiceRequest("nis", "2021-12-16", "GetVbrFlowTopN") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+GetVbrFlowTopNRequest::~GetVbrFlowTopNRequest() {}
+
+std::string GetVbrFlowTopNRequest::getOtherPort() const {
+  return otherPort_;
+}
+
+void GetVbrFlowTopNRequest::setOtherPort(const std::string &otherPort) {
+  otherPort_ = otherPort;
+  setParameter(std::string("OtherPort"), otherPort);
+}
+
+int GetVbrFlowTopNRequest::getTopN() const {
+  return topN_;
+}
+
+void GetVbrFlowTopNRequest::setTopN(int topN) {
+  topN_ = topN;
+  setParameter(std::string("TopN"), std::to_string(topN));
+}
+
+std::string GetVbrFlowTopNRequest::getCloudPort() const {
+  return cloudPort_;
+}
+
+void GetVbrFlowTopNRequest::setCloudPort(const std::string &cloudPort) {
+  cloudPort_ = cloudPort;
+  setParameter(std::string("CloudPort"), cloudPort);
+}
+
+std::string GetVbrFlowTopNRequest::getProtocol() const {
+  return protocol_;
+}
+
+void GetVbrFlowTopNRequest::setProtocol(const std::string &protocol) {
+  protocol_ = protocol;
+  setParameter(std::string("Protocol"), protocol);
+}
+
+std::string GetVbrFlowTopNRequest::getOtherIp() const {
+  return otherIp_;
+}
+
+void GetVbrFlowTopNRequest::setOtherIp(const std::string &otherIp) {
+  otherIp_ = otherIp;
+  setParameter(std::string("OtherIp"), otherIp);
+}
+
+std::string GetVbrFlowTopNRequest::getOrderBy() const {
+  return orderBy_;
+}
+
+void GetVbrFlowTopNRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
+}
+
+std::string GetVbrFlowTopNRequest::getSort() const {
+  return sort_;
+}
+
+void GetVbrFlowTopNRequest::setSort(const std::string &sort) {
+  sort_ = sort;
+  setParameter(std::string("Sort"), sort);
+}
+
+bool GetVbrFlowTopNRequest::getUseMultiAccount() const {
+  return useMultiAccount_;
+}
+
+void GetVbrFlowTopNRequest::setUseMultiAccount(bool useMultiAccount) {
+  useMultiAccount_ = useMultiAccount;
+  setParameter(std::string("UseMultiAccount"), useMultiAccount ? "true" : "false");
+}
+
+std::string GetVbrFlowTopNRequest::getCloudIp() const {
+  return cloudIp_;
+}
+
+void GetVbrFlowTopNRequest::setCloudIp(const std::string &cloudIp) {
+  cloudIp_ = cloudIp;
+  setParameter(std::string("CloudIp"), cloudIp);
+}
+
+std::string GetVbrFlowTopNRequest::getCenId() const {
+  return cenId_;
+}
+
+void GetVbrFlowTopNRequest::setCenId(const std::string &cenId) {
+  cenId_ = cenId;
+  setParameter(std::string("CenId"), cenId);
+}
+
+std::string GetVbrFlowTopNRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetVbrFlowTopNRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string GetVbrFlowTopNRequest::getVirtualBorderRouterId() const {
+  return virtualBorderRouterId_;
+}
+
+void GetVbrFlowTopNRequest::setVirtualBorderRouterId(const std::string &virtualBorderRouterId) {
+  virtualBorderRouterId_ = virtualBorderRouterId;
+  setParameter(std::string("VirtualBorderRouterId"), virtualBorderRouterId);
+}
+
+std::string GetVbrFlowTopNRequest::getDirection() const {
+  return direction_;
+}
+
+void GetVbrFlowTopNRequest::setDirection(const std::string &direction) {
+  direction_ = direction;
+  setParameter(std::string("Direction"), direction);
+}
+
+long GetVbrFlowTopNRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetVbrFlowTopNRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+long GetVbrFlowTopNRequest::getBeginTime() const {
+  return beginTime_;
+}
+
+void GetVbrFlowTopNRequest::setBeginTime(long beginTime) {
+  beginTime_ = beginTime;
+  setParameter(std::string("BeginTime"), std::to_string(beginTime));
+}
+
+std::string GetVbrFlowTopNRequest::getGroupBy() const {
+  return groupBy_;
+}
+
+void GetVbrFlowTopNRequest::setGroupBy(const std::string &groupBy) {
+  groupBy_ = groupBy;
+  setParameter(std::string("GroupBy"), groupBy);
+}
+
+std::vector<GetVbrFlowTopNRequest::long> GetVbrFlowTopNRequest::getAccountIds() const {
+  return accountIds_;
+}
+
+void GetVbrFlowTopNRequest::setAccountIds(const std::vector<GetVbrFlowTopNRequest::long> &accountIds) {
+  accountIds_ = accountIds;
+  for(int dep1 = 0; dep1 != accountIds.size(); dep1++) {
+    setParameter(std::string("AccountIds") + "." + std::to_string(dep1 + 1), std::to_string(accountIds[dep1]));
+  }
+}
+
+std::string GetVbrFlowTopNRequest::getAttachmentId() const {
+  return attachmentId_;
+}
+
+void GetVbrFlowTopNRequest::setAttachmentId(const std::string &attachmentId) {
+  attachmentId_ = attachmentId;
+  setParameter(std::string("AttachmentId"), attachmentId);
+}
+

nis/src/model/GetVbrFlowTopNResult.cc

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/nis/model/GetVbrFlowTopNResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Nis;
+using namespace AlibabaCloud::Nis::Model;
+
+GetVbrFlowTopNResult::GetVbrFlowTopNResult() :
+	ServiceResult()
+{}
+
+GetVbrFlowTopNResult::GetVbrFlowTopNResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetVbrFlowTopNResult::~GetVbrFlowTopNResult()
+{}
+
+void GetVbrFlowTopNResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allVirtualBorderRouterFlowlogTopNNode = value["VirtualBorderRouterFlowlogTopN"]["VbrFlowlogTopN"];
+	for (auto valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN : allVirtualBorderRouterFlowlogTopNNode)
+	{
+		VbrFlowlogTopN virtualBorderRouterFlowlogTopNObject;
+		if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudRegion"].isNull())
+			virtualBorderRouterFlowlogTopNObject.cloudRegion = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudRegion"].asString();
+		if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudIp"].isNull())
+			virtualBorderRouterFlowlogTopNObject.cloudIp = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudIp"].asString();
+		if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["OtherIp"].isNull())
+			virtualBorderRouterFlowlogTopNObject.otherIp = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["OtherIp"].asString();
+		if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudPort"].isNull())
+			virtualBorderRouterFlowlogTopNObject.cloudPort = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["CloudPort"].asString();
+		if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["OtherPort"].isNull())
+			virtualBorderRouterFlowlogTopNObject.otherPort = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["OtherPort"].asString();
+		if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Protocol"].isNull())
+			virtualBorderRouterFlowlogTopNObject.protocol = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Protocol"].asString();
+		if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["AttachmentId"].isNull())
+			virtualBorderRouterFlowlogTopNObject.attachmentId = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["AttachmentId"].asString();
+		if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["VirtualBorderRouterId"].isNull())
+			virtualBorderRouterFlowlogTopNObject.virtualBorderRouterId = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["VirtualBorderRouterId"].asString();
+		if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Bytes"].isNull())
+			virtualBorderRouterFlowlogTopNObject.bytes = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Bytes"].asString();
+		if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Packets"].isNull())
+			virtualBorderRouterFlowlogTopNObject.packets = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["Packets"].asString();
+		if(!valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["AccountId"].isNull())
+			virtualBorderRouterFlowlogTopNObject.accountId = valueVirtualBorderRouterFlowlogTopNVbrFlowlogTopN["AccountId"].asString();
+		virtualBorderRouterFlowlogTopN_.push_back(virtualBorderRouterFlowlogTopNObject);
+	}
+
+}
+
+std::vector<GetVbrFlowTopNResult::VbrFlowlogTopN> GetVbrFlowTopNResult::getVirtualBorderRouterFlowlogTopN()const
+{
+	return virtualBorderRouterFlowlogTopN_;
+}
+