Generated 2019-05-06 for sae.

VERSION

@@ -1 +1 @@
-1.36.1892
+1.36.1893

sae/CMakeLists.txt

@@ -131,6 +131,16 @@ set(sae_public_header_model
 	include/alibabacloud/sae/model/EnableApplicationScalingRuleResult.h
 	include/alibabacloud/sae/model/ExecJobRequest.h
 	include/alibabacloud/sae/model/ExecJobResult.h
+	include/alibabacloud/sae/model/GetArmsTopNMetricRequest.h
+	include/alibabacloud/sae/model/GetArmsTopNMetricResult.h
+	include/alibabacloud/sae/model/GetAvailabilityMetricRequest.h
+	include/alibabacloud/sae/model/GetAvailabilityMetricResult.h
+	include/alibabacloud/sae/model/GetChangeOrderMetricRequest.h
+	include/alibabacloud/sae/model/GetChangeOrderMetricResult.h
+	include/alibabacloud/sae/model/GetScaleAppMetricRequest.h
+	include/alibabacloud/sae/model/GetScaleAppMetricResult.h
+	include/alibabacloud/sae/model/GetWarningEventMetricRequest.h
+	include/alibabacloud/sae/model/GetWarningEventMetricResult.h
 	include/alibabacloud/sae/model/ListAppEventsRequest.h
 	include/alibabacloud/sae/model/ListAppEventsResult.h
 	include/alibabacloud/sae/model/ListAppServicesPageRequest.h
@@ -324,6 +334,16 @@ set(sae_src
 	src/model/EnableApplicationScalingRuleResult.cc
 	src/model/ExecJobRequest.cc
 	src/model/ExecJobResult.cc
+	src/model/GetArmsTopNMetricRequest.cc
+	src/model/GetArmsTopNMetricResult.cc
+	src/model/GetAvailabilityMetricRequest.cc
+	src/model/GetAvailabilityMetricResult.cc
+	src/model/GetChangeOrderMetricRequest.cc
+	src/model/GetChangeOrderMetricResult.cc
+	src/model/GetScaleAppMetricRequest.cc
+	src/model/GetScaleAppMetricResult.cc
+	src/model/GetWarningEventMetricRequest.cc
+	src/model/GetWarningEventMetricResult.cc
 	src/model/ListAppEventsRequest.cc
 	src/model/ListAppEventsResult.cc
 	src/model/ListAppServicesPageRequest.cc

sae/include/alibabacloud/sae/SaeClient.h

@@ -132,6 +132,16 @@
 #include "model/EnableApplicationScalingRuleResult.h"
 #include "model/ExecJobRequest.h"
 #include "model/ExecJobResult.h"
+#include "model/GetArmsTopNMetricRequest.h"
+#include "model/GetArmsTopNMetricResult.h"
+#include "model/GetAvailabilityMetricRequest.h"
+#include "model/GetAvailabilityMetricResult.h"
+#include "model/GetChangeOrderMetricRequest.h"
+#include "model/GetChangeOrderMetricResult.h"
+#include "model/GetScaleAppMetricRequest.h"
+#include "model/GetScaleAppMetricResult.h"
+#include "model/GetWarningEventMetricRequest.h"
+#include "model/GetWarningEventMetricResult.h"
 #include "model/ListAppEventsRequest.h"
 #include "model/ListAppEventsResult.h"
 #include "model/ListAppServicesPageRequest.h"
@@ -386,6 +396,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ExecJobResult> ExecJobOutcome;
 			typedef std::future<ExecJobOutcome> ExecJobOutcomeCallable;
 			typedef std::function<void(const SaeClient*, const Model::ExecJobRequest&, const ExecJobOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ExecJobAsyncHandler;
+			typedef Outcome<Error, Model::GetArmsTopNMetricResult> GetArmsTopNMetricOutcome;
+			typedef std::future<GetArmsTopNMetricOutcome> GetArmsTopNMetricOutcomeCallable;
+			typedef std::function<void(const SaeClient*, const Model::GetArmsTopNMetricRequest&, const GetArmsTopNMetricOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetArmsTopNMetricAsyncHandler;
+			typedef Outcome<Error, Model::GetAvailabilityMetricResult> GetAvailabilityMetricOutcome;
+			typedef std::future<GetAvailabilityMetricOutcome> GetAvailabilityMetricOutcomeCallable;
+			typedef std::function<void(const SaeClient*, const Model::GetAvailabilityMetricRequest&, const GetAvailabilityMetricOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAvailabilityMetricAsyncHandler;
+			typedef Outcome<Error, Model::GetChangeOrderMetricResult> GetChangeOrderMetricOutcome;
+			typedef std::future<GetChangeOrderMetricOutcome> GetChangeOrderMetricOutcomeCallable;
+			typedef std::function<void(const SaeClient*, const Model::GetChangeOrderMetricRequest&, const GetChangeOrderMetricOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetChangeOrderMetricAsyncHandler;
+			typedef Outcome<Error, Model::GetScaleAppMetricResult> GetScaleAppMetricOutcome;
+			typedef std::future<GetScaleAppMetricOutcome> GetScaleAppMetricOutcomeCallable;
+			typedef std::function<void(const SaeClient*, const Model::GetScaleAppMetricRequest&, const GetScaleAppMetricOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetScaleAppMetricAsyncHandler;
+			typedef Outcome<Error, Model::GetWarningEventMetricResult> GetWarningEventMetricOutcome;
+			typedef std::future<GetWarningEventMetricOutcome> GetWarningEventMetricOutcomeCallable;
+			typedef std::function<void(const SaeClient*, const Model::GetWarningEventMetricRequest&, const GetWarningEventMetricOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetWarningEventMetricAsyncHandler;
 			typedef Outcome<Error, Model::ListAppEventsResult> ListAppEventsOutcome;
 			typedef std::future<ListAppEventsOutcome> ListAppEventsOutcomeCallable;
 			typedef std::function<void(const SaeClient*, const Model::ListAppEventsRequest&, const ListAppEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListAppEventsAsyncHandler;
@@ -676,6 +701,21 @@ namespace AlibabaCloud
 			ExecJobOutcome execJob(const Model::ExecJobRequest &request)const;
 			void execJobAsync(const Model::ExecJobRequest& request, const ExecJobAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ExecJobOutcomeCallable execJobCallable(const Model::ExecJobRequest& request) const;
+			GetArmsTopNMetricOutcome getArmsTopNMetric(const Model::GetArmsTopNMetricRequest &request)const;
+			void getArmsTopNMetricAsync(const Model::GetArmsTopNMetricRequest& request, const GetArmsTopNMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetArmsTopNMetricOutcomeCallable getArmsTopNMetricCallable(const Model::GetArmsTopNMetricRequest& request) const;
+			GetAvailabilityMetricOutcome getAvailabilityMetric(const Model::GetAvailabilityMetricRequest &request)const;
+			void getAvailabilityMetricAsync(const Model::GetAvailabilityMetricRequest& request, const GetAvailabilityMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetAvailabilityMetricOutcomeCallable getAvailabilityMetricCallable(const Model::GetAvailabilityMetricRequest& request) const;
+			GetChangeOrderMetricOutcome getChangeOrderMetric(const Model::GetChangeOrderMetricRequest &request)const;
+			void getChangeOrderMetricAsync(const Model::GetChangeOrderMetricRequest& request, const GetChangeOrderMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetChangeOrderMetricOutcomeCallable getChangeOrderMetricCallable(const Model::GetChangeOrderMetricRequest& request) const;
+			GetScaleAppMetricOutcome getScaleAppMetric(const Model::GetScaleAppMetricRequest &request)const;
+			void getScaleAppMetricAsync(const Model::GetScaleAppMetricRequest& request, const GetScaleAppMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetScaleAppMetricOutcomeCallable getScaleAppMetricCallable(const Model::GetScaleAppMetricRequest& request) const;
+			GetWarningEventMetricOutcome getWarningEventMetric(const Model::GetWarningEventMetricRequest &request)const;
+			void getWarningEventMetricAsync(const Model::GetWarningEventMetricRequest& request, const GetWarningEventMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetWarningEventMetricOutcomeCallable getWarningEventMetricCallable(const Model::GetWarningEventMetricRequest& request) const;
 			ListAppEventsOutcome listAppEvents(const Model::ListAppEventsRequest &request)const;
 			void listAppEventsAsync(const Model::ListAppEventsRequest& request, const ListAppEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ListAppEventsOutcomeCallable listAppEventsCallable(const Model::ListAppEventsRequest& request) const;

sae/include/alibabacloud/sae/model/BatchStartApplicationsRequest.h

@@ -34,10 +34,13 @@ public:
 	void setAppIds(const std::string &appIds);
 	std::string getNamespaceId() const;
 	void setNamespaceId(const std::string &namespaceId);
+	std::string getVersion() const;
+	void setVersion(const std::string &version);
 
 private:
 	std::string appIds_;
 	std::string namespaceId_;
+	std::string version_;
 };
 } // namespace Model
 } // namespace Sae

sae/include/alibabacloud/sae/model/BatchStopApplicationsRequest.h

@@ -34,10 +34,13 @@ public:
 	void setAppIds(const std::string &appIds);
 	std::string getNamespaceId() const;
 	void setNamespaceId(const std::string &namespaceId);
+	std::string getVersion() const;
+	void setVersion(const std::string &version);
 
 private:
 	std::string appIds_;
 	std::string namespaceId_;
+	std::string version_;
 };
 } // namespace Model
 } // namespace Sae

sae/include/alibabacloud/sae/model/CreateApplicationRequest.h

@@ -62,6 +62,8 @@ public:
 	void setNamespaceId(const std::string &namespaceId);
 	bool getPurchaseEip() const;
 	void setPurchaseEip(bool purchaseEip);
+	std::string getSaeVersion() const;
+	void setSaeVersion(const std::string &saeVersion);
 	std::string getPvtzDiscoverySvc() const;
 	void setPvtzDiscoverySvc(const std::string &pvtzDiscoverySvc);
 	std::string getConfigMapMountDesc() const;
@@ -78,6 +80,8 @@ public:
 	void setCpu(int cpu);
 	std::string getVSwitchId() const;
 	void setVSwitchId(const std::string &vSwitchId);
+	std::string getEnableEbpf() const;
+	void setEnableEbpf(const std::string &enableEbpf);
 	std::string getPackageType() const;
 	void setPackageType(const std::string &packageType);
 	std::string getPostStart() const;
@@ -86,6 +90,8 @@ public:
 	void setPhpExtensions(const std::string &phpExtensions);
 	bool getAssociateEip() const;
 	void setAssociateEip(bool associateEip);
+	std::string getAppSource() const;
+	void setAppSource(const std::string &appSource);
 	std::string getWebContainer() const;
 	void setWebContainer(const std::string &webContainer);
 	int getMemory() const;
@@ -168,6 +174,7 @@ private:
 	std::string appName_;
 	std::string namespaceId_;
 	bool purchaseEip_;
+	std::string saeVersion_;
 	std::string pvtzDiscoverySvc_;
 	std::string configMapMountDesc_;
 	std::string ossMountDescs_;
@@ -176,10 +183,12 @@ private:
 	std::string python_;
 	int cpu_;
 	std::string vSwitchId_;
+	std::string enableEbpf_;
 	std::string packageType_;
 	std::string postStart_;
 	std::string phpExtensions_;
 	bool associateEip_;
+	std::string appSource_;
 	std::string webContainer_;
 	int memory_;
 	std::string slsConfigs_;

sae/include/alibabacloud/sae/model/CreateApplicationScalingRuleResult.h

@@ -40,6 +40,8 @@ namespace AlibabaCloud
 						{
 							int targetReplicas;
 							std::string atTime;
+							int minReplicas;
+							int maxReplicas;
 						};
 						std::vector<Schedule> schedules;
 						std::string period;
@@ -50,7 +52,11 @@ namespace AlibabaCloud
 					{
 						struct Metric1
 						{
+							std::string slbId;
 							std::string metricType;
+							std::string vport;
+							std::string slbLogstore;
+							std::string slbProject;
 							int metricTargetAverageUtilization;
 						};
 						std::vector<Metric1> metrics;
@@ -72,14 +78,22 @@ namespace AlibabaCloud
 				CreateApplicationScalingRuleResult();
 				explicit CreateApplicationScalingRuleResult(const std::string &payload);
 				~CreateApplicationScalingRuleResult();
+				std::string getMessage()const;
 				std::string getTraceId()const;
 				Data getData()const;
+				std::string getErrorCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string message_;
 				std::string traceId_;
 				Data data_;
+				std::string errorCode_;
+				std::string code_;
+				bool success_;
 
 			};
 		}

sae/include/alibabacloud/sae/model/CreateGreyTagRouteRequest.h

@@ -38,6 +38,8 @@ public:
 	void setDescription(const std::string &description);
 	std::string getDubboRules() const;
 	void setDubboRules(const std::string &dubboRules);
+	std::string getAlbRules() const;
+	void setAlbRules(const std::string &albRules);
 	std::string getScRules() const;
 	void setScRules(const std::string &scRules);
 
@@ -46,6 +48,7 @@ private:
 	std::string name_;
 	std::string description_;
 	std::string dubboRules_;
+	std::string albRules_;
 	std::string scRules_;
 };
 } // namespace Model

sae/include/alibabacloud/sae/model/CreateNamespaceRequest.h

@@ -34,13 +34,19 @@ public:
 	void setNamespaceName(const std::string &namespaceName);
 	std::string getNamespaceDescription() const;
 	void setNamespaceDescription(const std::string &namespaceDescription);
+	bool getEnableMicroRegistration() const;
+	void setEnableMicroRegistration(bool enableMicroRegistration);
 	std::string getNamespaceId() const;
 	void setNamespaceId(const std::string &namespaceId);
+	std::string getNameSpaceShortId() const;
+	void setNameSpaceShortId(const std::string &nameSpaceShortId);
 
 private:
 	std::string namespaceName_;
 	std::string namespaceDescription_;
+	bool enableMicroRegistration_;
 	std::string namespaceId_;
+	std::string nameSpaceShortId_;
 };
 } // namespace Model
 } // namespace Sae

sae/include/alibabacloud/sae/model/CreateNamespaceResult.h

@@ -34,10 +34,12 @@ namespace AlibabaCloud
 			public:
 				struct Data
 				{
+					std::string nameSpaceShortId;
 					std::string namespaceName;
 					std::string namespaceId;
 					std::string regionId;
 					std::string namespaceDescription;
+					bool enableMicroRegistration;
 				};
 
 

sae/include/alibabacloud/sae/model/DeleteApplicationScalingRuleResult.h

@@ -37,12 +37,20 @@ namespace AlibabaCloud
 				DeleteApplicationScalingRuleResult();
 				explicit DeleteApplicationScalingRuleResult(const std::string &payload);
 				~DeleteApplicationScalingRuleResult();
+				std::string getMessage()const;
 				std::string getTraceId()const;
+				std::string getErrorCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string message_;
 				std::string traceId_;
+				std::string errorCode_;
+				std::string code_;
+				bool success_;
 
 			};
 		}

sae/include/alibabacloud/sae/model/DeleteNamespaceRequest.h

@@ -32,9 +32,12 @@ public:
 	~DeleteNamespaceRequest();
 	std::string getNamespaceId() const;
 	void setNamespaceId(const std::string &namespaceId);
+	std::string getNameSpaceShortId() const;
+	void setNameSpaceShortId(const std::string &nameSpaceShortId);
 
 private:
 	std::string namespaceId_;
+	std::string nameSpaceShortId_;
 };
 } // namespace Model
 } // namespace Sae

sae/include/alibabacloud/sae/model/DeployApplicationRequest.h

@@ -66,14 +66,20 @@ public:
 	void setPreStop(const std::string &preStop);
 	std::string getPython() const;
 	void setPython(const std::string &python);
+	int getCpu() const;
+	void setCpu(int cpu);
 	std::string getUpdateStrategy() const;
 	void setUpdateStrategy(const std::string &updateStrategy);
+	std::string getVSwitchId() const;
+	void setVSwitchId(const std::string &vSwitchId);
 	std::string getChangeOrderDesc() const;
 	void setChangeOrderDesc(const std::string &changeOrderDesc);
 	int getMinReadyInstanceRatio() const;
 	void setMinReadyInstanceRatio(int minReadyInstanceRatio);
 	bool getAutoEnableApplicationScalingRule() const;
 	void setAutoEnableApplicationScalingRule(bool autoEnableApplicationScalingRule);
+	std::string getPackageType() const;
+	void setPackageType(const std::string &packageType);
 	std::string getPostStart() const;
 	void setPostStart(const std::string &postStart);
 	std::string getPhpExtensions() const;
@@ -88,6 +94,8 @@ public:
 	void setSlsConfigs(const std::string &slsConfigs);
 	std::string getKafkaConfigs() const;
 	void setKafkaConfigs(const std::string &kafkaConfigs);
+	int getMemory() const;
+	void setMemory(int memory);
 	std::string getCommandArgs() const;
 	void setCommandArgs(const std::string &commandArgs);
 	std::string getAcrAssumeRoleArn() const;
@@ -100,6 +108,8 @@ public:
 	void setOssAkId(const std::string &ossAkId);
 	std::string getLiveness() const;
 	void setLiveness(const std::string &liveness);
+	std::string getSecurityGroupId() const;
+	void setSecurityGroupId(const std::string &securityGroupId);
 	std::string getPackageVersion() const;
 	void setPackageVersion(const std::string &packageVersion);
 	std::string getTomcatConfig() const;
@@ -122,6 +132,8 @@ public:
 	void setMicroRegistration(const std::string &microRegistration);
 	bool getEnableGreyTagRoute() const;
 	void setEnableGreyTagRoute(bool enableGreyTagRoute);
+	int getReplicas() const;
+	void setReplicas(int replicas);
 	std::string getCommand() const;
 	void setCommand(const std::string &command);
 	std::string getMountDesc() const;
@@ -162,10 +174,13 @@ private:
 	std::string imagePullSecrets_;
 	std::string preStop_;
 	std::string python_;
+	int cpu_;
 	std::string updateStrategy_;
+	std::string vSwitchId_;
 	std::string changeOrderDesc_;
 	int minReadyInstanceRatio_;
 	bool autoEnableApplicationScalingRule_;
+	std::string packageType_;
 	std::string postStart_;
 	std::string phpExtensions_;
 	bool associateEip_;
@@ -173,12 +188,14 @@ private:
 	std::string enableAhas_;
 	std::string slsConfigs_;
 	std::string kafkaConfigs_;
+	int memory_;
 	std::string commandArgs_;
 	std::string acrAssumeRoleArn_;
 	std::string readiness_;
 	std::string timezone_;
 	std::string ossAkId_;
 	std::string liveness_;
+	std::string securityGroupId_;
 	std::string packageVersion_;
 	std::string tomcatConfig_;
 	std::string warStartOptions_;
@@ -190,6 +207,7 @@ private:
 	bool enableImageAccl_;
 	std::string microRegistration_;
 	bool enableGreyTagRoute_;
+	int replicas_;
 	std::string command_;
 	std::string mountDesc_;
 	std::string jdk_;

sae/include/alibabacloud/sae/model/DescribeApplicationConfigResult.h

@@ -106,14 +106,17 @@ namespace AlibabaCloud
 					std::string php;
 					std::string commandArgs;
 					std::string acrAssumeRoleArn;
+					std::string saeVersion;
 					int terminationGracePeriodSeconds;
 					std::string securityGroupId;
 					std::string envs;
+					std::string mseApplicationName;
 					std::string jarStartOptions;
 					std::string mountHost;
 					std::string imagePullSecrets;
 					int replicas;
 					std::string customHostAlias;
+					std::string appSource;
 					std::string packageRuntimeCustomBuild;
 					std::string command;
 					bool associateEip;

sae/include/alibabacloud/sae/model/DescribeApplicationScalingRuleResult.h

@@ -40,6 +40,8 @@ namespace AlibabaCloud
 						{
 							int targetReplicas;
 							std::string atTime;
+							int minReplicas;
+							int maxReplicas;
 						};
 						std::vector<Schedule> schedules;
 						std::string period;
@@ -83,7 +85,11 @@ namespace AlibabaCloud
 						};
 						struct Metric1
 						{
+							std::string slbId;
 							std::string metricType;
+							std::string vport;
+							std::string slbLogstore;
+							std::string slbProject;
 							int metricTargetAverageUtilization;
 						};
 						std::vector<Metric1> metrics;
@@ -97,9 +103,11 @@ namespace AlibabaCloud
 					Timer timer;
 					std::string appId;
 					long lastDisableTime;
+					int minReadyInstances;
 					long createTime;
 					long updateTime;
 					Metric metric;
+					int minReadyInstanceRatio;
 					std::string scaleRuleName;
 					std::string scaleRuleType;
 				};
@@ -108,14 +116,22 @@ namespace AlibabaCloud
 				DescribeApplicationScalingRuleResult();
 				explicit DescribeApplicationScalingRuleResult(const std::string &payload);
 				~DescribeApplicationScalingRuleResult();
+				std::string getMessage()const;
 				std::string getTraceId()const;
 				Data getData()const;
+				std::string getErrorCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string message_;
 				std::string traceId_;
 				Data data_;
+				std::string errorCode_;
+				std::string code_;
+				bool success_;
 
 			};
 		}

sae/include/alibabacloud/sae/model/DescribeApplicationScalingRulesResult.h

@@ -89,7 +89,11 @@ namespace AlibabaCloud
 							};
 							struct Metric1
 							{
+								std::string slbId;
 								std::string metricType;
+								std::string vport;
+								std::string slbLogstore;
+								std::string slbProject;
 								int metricTargetAverageUtilization;
 							};
 							std::vector<Metric1> metrics;
@@ -103,9 +107,11 @@ namespace AlibabaCloud
 						Timer timer;
 						std::string appId;
 						long lastDisableTime;
+						int minReadyInstances;
 						long createTime;
 						long updateTime;
 						Metric metric;
+						int minReadyInstanceRatio;
 						std::string scaleRuleName;
 						std::string scaleRuleType;
 					};
@@ -119,14 +125,22 @@ namespace AlibabaCloud
 				DescribeApplicationScalingRulesResult();
 				explicit DescribeApplicationScalingRulesResult(const std::string &payload);
 				~DescribeApplicationScalingRulesResult();
+				std::string getMessage()const;
 				std::string getTraceId()const;
 				Data getData()const;
+				std::string getErrorCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string message_;
 				std::string traceId_;
 				Data data_;
+				std::string errorCode_;
+				std::string code_;
+				bool success_;
 
 			};
 		}

sae/include/alibabacloud/sae/model/DescribeConfigurationPriceResult.h

@@ -46,14 +46,68 @@ namespace AlibabaCloud
 						float originalAmount;
 						float discountAmount;
 					};
+					struct RequestPrice
+					{
+						struct Order1
+						{
+							float tradeAmount;
+							float originalAmount;
+							float discountAmount;
+							std::vector<std::string> ruleIds4;
+						};
+						struct Rule3
+						{
+							long ruleDescId;
+							std::string name;
+						};
+						Order1 order1;
+						std::vector<Rule3> rules2;
+					};
+					struct TrafficPrice
+					{
+						struct Order5
+						{
+							std::vector<std::string> ruleIds8;
+							float tradeAmount;
+							float originalAmount;
+							float discountAmount;
+						};
+						struct Rule7
+						{
+							float ruleDescId;
+							std::string name;
+						};
+						Order5 order5;
+						std::vector<Rule7> rules6;
+					};
+					struct CpuMemPrice
+					{
+						struct Order9
+						{
+							float tradeAmount;
+							float originalAmount;
+							float discountAmount;
+							std::vector<std::string> ruleIds12;
+						};
+						struct Rule11
+						{
+							float ruleDescId;
+							std::string name;
+						};
+						std::vector<Rule11> rules10;
+						Order9 order9;
+					};
 					struct Rule
 					{
 						long ruleDescId;
 						std::string name;
 					};
 					Order order;
+					TrafficPrice trafficPrice;
+					CpuMemPrice cpuMemPrice;
 					BagUsage bagUsage;
 					std::vector<Rule> rules;
+					RequestPrice requestPrice;
 				};
 
 

sae/include/alibabacloud/sae/model/DescribeGreyTagRouteResult.h

@@ -50,6 +50,23 @@ namespace AlibabaCloud
 						std::string condition;
 						std::vector<ScRule::Scrulesitem> items;
 					};
+					struct AlbRule
+					{
+						struct Scrulesitem2
+						{
+							std::string type;
+							std::string cond;
+							std::string expr;
+							std::string value;
+							std::string _operator;
+							int index;
+							std::string name;
+						};
+						std::string condition;
+						std::string ingressId;
+						std::vector<AlbRule::Scrulesitem2> items1;
+						std::string serviceId;
+					};
 					struct DubboRule
 					{
 						struct Item
@@ -67,8 +84,9 @@ namespace AlibabaCloud
 						std::string serviceName;
 						std::string version;
 						std::string methodName;
-						std::vector<DubboRule::Item> items1;
+						std::vector<DubboRule::Item> items3;
 					};
+					std::vector<AlbRule> albRules;
 					long greyTagRouteId;
 					std::string description;
 					std::string appId;

sae/include/alibabacloud/sae/model/DescribeIngressResult.h

@@ -46,10 +46,19 @@ namespace AlibabaCloud
 						std::string path;
 						std::string backendProtocol;
 						std::string appId;
+						std::string rewritePath;
 						int containerPort;
 						std::string domain;
 						std::string appName;
 					};
+					struct Svc
+					{
+						std::string backendProtocol;
+						std::string appId;
+						int backendPort;
+						long id;
+						std::string name;
+					};
 					DefaultRule defaultRule;
 					std::string slbId;
 					int listenerPort;
@@ -59,6 +68,7 @@ namespace AlibabaCloud
 					std::string listenerProtocol;
 					std::vector<Rule> rules;
 					std::string name;
+					std::vector<Svc> svcs;
 					std::string loadBalanceType;
 					std::string namespaceId;
 					long id;

sae/include/alibabacloud/sae/model/DescribeNamespaceListResult.h

@@ -34,6 +34,7 @@ namespace AlibabaCloud
 			public:
 				struct RegionList
 				{
+					std::string nameSpaceShortId;
 					std::string namespaceName;
 					std::string vpcId;
 					std::string vSwitchId;

sae/include/alibabacloud/sae/model/DescribeNamespaceRequest.h

@@ -32,9 +32,12 @@ public:
 	~DescribeNamespaceRequest();
 	std::string getNamespaceId() const;
 	void setNamespaceId(const std::string &namespaceId);
+	std::string getNameSpaceShortId() const;
+	void setNameSpaceShortId(const std::string &nameSpaceShortId);
 
 private:
 	std::string namespaceId_;
+	std::string nameSpaceShortId_;
 };
 } // namespace Model
 } // namespace Sae

sae/include/alibabacloud/sae/model/DescribeNamespaceResourcesRequest.h

@@ -32,9 +32,12 @@ public:
 	~DescribeNamespaceResourcesRequest();
 	std::string getNamespaceId() const;
 	void setNamespaceId(const std::string &namespaceId);
+	std::string getNameSpaceShortId() const;
+	void setNameSpaceShortId(const std::string &nameSpaceShortId);
 
 private:
 	std::string namespaceId_;
+	std::string nameSpaceShortId_;
 };
 } // namespace Model
 } // namespace Sae

sae/include/alibabacloud/sae/model/DescribeNamespaceResourcesResult.h

@@ -40,6 +40,7 @@ namespace AlibabaCloud
 					long appCount;
 					bool notificationExpired;
 					std::string belongRegion;
+					std::string nameSpaceShortId;
 					std::string namespaceName;
 					std::string tenantId;
 					std::string vpcId;

sae/include/alibabacloud/sae/model/DescribeNamespaceResult.h

@@ -34,10 +34,12 @@ namespace AlibabaCloud
 			public:
 				struct Data
 				{
+					std::string nameSpaceShortId;
 					std::string namespaceName;
 					std::string namespaceId;
 					std::string regionId;
 					std::string namespaceDescription;
+					bool enableMicroRegistration;
 				};
 
 

sae/include/alibabacloud/sae/model/DescribeNamespacesResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					struct _Namespace
 					{
+						std::string nameSpaceShortId;
 						std::string namespaceName;
 						std::string secretKey;
 						std::string tenantId;

sae/include/alibabacloud/sae/model/DescribePipelineResult.h

@@ -45,6 +45,9 @@ namespace AlibabaCloud
 							std::string taskName;
 							bool showManualIgnore;
 							std::string stageId;
+							long createTime;
+							long startTime;
+							long updateTime;
 							std::string errorCode;
 							std::string errorMessage;
 						};

sae/include/alibabacloud/sae/model/DisableApplicationScalingRuleResult.h

@@ -37,12 +37,20 @@ namespace AlibabaCloud
 				DisableApplicationScalingRuleResult();
 				explicit DisableApplicationScalingRuleResult(const std::string &payload);
 				~DisableApplicationScalingRuleResult();
+				std::string getMessage()const;
 				std::string getTraceId()const;
+				std::string getErrorCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string message_;
 				std::string traceId_;
+				std::string errorCode_;
+				std::string code_;
+				bool success_;
 
 			};
 		}

sae/include/alibabacloud/sae/model/EnableApplicationScalingRuleResult.h

@@ -37,12 +37,20 @@ namespace AlibabaCloud
 				EnableApplicationScalingRuleResult();
 				explicit EnableApplicationScalingRuleResult(const std::string &payload);
 				~EnableApplicationScalingRuleResult();
+				std::string getMessage()const;
 				std::string getTraceId()const;
+				std::string getErrorCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string message_;
 				std::string traceId_;
+				std::string errorCode_;
+				std::string code_;
+				bool success_;
 
 			};
 		}

sae/include/alibabacloud/sae/model/ExecJobRequest.h

@@ -38,6 +38,8 @@ public:
 	void setJarStartArgs(const std::string &jarStartArgs);
 	std::string getCommandArgs() const;
 	void setCommandArgs(const std::string &commandArgs);
+	std::string getReplicas() const;
+	void setReplicas(const std::string &replicas);
 	std::string getAppId() const;
 	void setAppId(const std::string &appId);
 	std::string getEnvs() const;
@@ -54,6 +56,7 @@ private:
 	std::string jarStartOptions_;
 	std::string jarStartArgs_;
 	std::string commandArgs_;
+	std::string replicas_;
 	std::string appId_;
 	std::string envs_;
 	std::string time_;

sae/include/alibabacloud/sae/model/GetArmsTopNMetricRequest.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_SAE_MODEL_GETARMSTOPNMETRICREQUEST_H_
+#define ALIBABACLOUD_SAE_MODEL_GETARMSTOPNMETRICREQUEST_H_
+
+#include <alibabacloud/sae/SaeExport.h>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Sae {
+namespace Model {
+class ALIBABACLOUD_SAE_EXPORT GetArmsTopNMetricRequest : public RoaServiceRequest {
+public:
+	GetArmsTopNMetricRequest();
+	~GetArmsTopNMetricRequest();
+	std::string getAppSource() const;
+	void setAppSource(const std::string &appSource);
+	std::string getCpuStrategy() const;
+	void setCpuStrategy(const std::string &cpuStrategy);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getLimit() const;
+	void setLimit(long limit);
+	std::string getOrderBy() const;
+	void setOrderBy(const std::string &orderBy);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getStartTime() const;
+	void setStartTime(long startTime);
+
+private:
+	std::string appSource_;
+	std::string cpuStrategy_;
+	std::string regionId_;
+	long limit_;
+	std::string orderBy_;
+	long endTime_;
+	long startTime_;
+};
+} // namespace Model
+} // namespace Sae
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SAE_MODEL_GETARMSTOPNMETRICREQUEST_H_

sae/include/alibabacloud/sae/model/GetArmsTopNMetricResult.h

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

sae/include/alibabacloud/sae/model/GetAvailabilityMetricRequest.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_SAE_MODEL_GETAVAILABILITYMETRICREQUEST_H_
+#define ALIBABACLOUD_SAE_MODEL_GETAVAILABILITYMETRICREQUEST_H_
+
+#include <alibabacloud/sae/SaeExport.h>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Sae {
+namespace Model {
+class ALIBABACLOUD_SAE_EXPORT GetAvailabilityMetricRequest : public RoaServiceRequest {
+public:
+	GetAvailabilityMetricRequest();
+	~GetAvailabilityMetricRequest();
+	std::string getAppSource() const;
+	void setAppSource(const std::string &appSource);
+	std::string getCpuStrategy() const;
+	void setCpuStrategy(const std::string &cpuStrategy);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getLimit() const;
+	void setLimit(long limit);
+
+private:
+	std::string appSource_;
+	std::string cpuStrategy_;
+	std::string regionId_;
+	long limit_;
+};
+} // namespace Model
+} // namespace Sae
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SAE_MODEL_GETAVAILABILITYMETRICREQUEST_H_

sae/include/alibabacloud/sae/model/GetAvailabilityMetricResult.h

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

sae/include/alibabacloud/sae/model/GetChangeOrderMetricRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SAE_MODEL_GETCHANGEORDERMETRICREQUEST_H_
+#define ALIBABACLOUD_SAE_MODEL_GETCHANGEORDERMETRICREQUEST_H_
+
+#include <alibabacloud/sae/SaeExport.h>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Sae {
+namespace Model {
+class ALIBABACLOUD_SAE_EXPORT GetChangeOrderMetricRequest : public RoaServiceRequest {
+public:
+	GetChangeOrderMetricRequest();
+	~GetChangeOrderMetricRequest();
+	std::string getAppSource() const;
+	void setAppSource(const std::string &appSource);
+	std::string getCreateTime() const;
+	void setCreateTime(const std::string &createTime);
+	std::string getCpuStrategy() const;
+	void setCpuStrategy(const std::string &cpuStrategy);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getLimit() const;
+	void setLimit(long limit);
+	std::string getOrderBy() const;
+	void setOrderBy(const std::string &orderBy);
+
+private:
+	std::string appSource_;
+	std::string createTime_;
+	std::string cpuStrategy_;
+	std::string regionId_;
+	long limit_;
+	std::string orderBy_;
+};
+} // namespace Model
+} // namespace Sae
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SAE_MODEL_GETCHANGEORDERMETRICREQUEST_H_

sae/include/alibabacloud/sae/model/GetChangeOrderMetricResult.h

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

sae/include/alibabacloud/sae/model/GetScaleAppMetricRequest.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_SAE_MODEL_GETSCALEAPPMETRICREQUEST_H_
+#define ALIBABACLOUD_SAE_MODEL_GETSCALEAPPMETRICREQUEST_H_
+
+#include <alibabacloud/sae/SaeExport.h>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Sae {
+namespace Model {
+class ALIBABACLOUD_SAE_EXPORT GetScaleAppMetricRequest : public RoaServiceRequest {
+public:
+	GetScaleAppMetricRequest();
+	~GetScaleAppMetricRequest();
+	std::string getAppSource() const;
+	void setAppSource(const std::string &appSource);
+	std::string getCpuStrategy() const;
+	void setCpuStrategy(const std::string &cpuStrategy);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getLimit() const;
+	void setLimit(long limit);
+
+private:
+	std::string appSource_;
+	std::string cpuStrategy_;
+	std::string regionId_;
+	long limit_;
+};
+} // namespace Model
+} // namespace Sae
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SAE_MODEL_GETSCALEAPPMETRICREQUEST_H_

sae/include/alibabacloud/sae/model/GetScaleAppMetricResult.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_SAE_MODEL_GETSCALEAPPMETRICRESULT_H_
+#define ALIBABACLOUD_SAE_MODEL_GETSCALEAPPMETRICRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/sae/SaeExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Sae
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_SAE_EXPORT GetScaleAppMetricResult : public ServiceResult
+			{
+			public:
+				struct ScaleAppMetricDto
+				{
+					std::string appId;
+					long maxReplicas;
+					long runnings;
+					std::string regionId;
+					std::string name;
+				};
+
+
+				GetScaleAppMetricResult();
+				explicit GetScaleAppMetricResult(const std::string &payload);
+				~GetScaleAppMetricResult();
+				std::string getMessage()const;
+				std::vector<ScaleAppMetricDto> getData()const;
+				std::string getCode()const;
+				bool getSuccess()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::vector<ScaleAppMetricDto> data_;
+				std::string code_;
+				bool success_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_SAE_MODEL_GETSCALEAPPMETRICRESULT_H_

sae/include/alibabacloud/sae/model/GetWarningEventMetricRequest.h

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_SAE_MODEL_GETWARNINGEVENTMETRICREQUEST_H_
+#define ALIBABACLOUD_SAE_MODEL_GETWARNINGEVENTMETRICREQUEST_H_
+
+#include <alibabacloud/sae/SaeExport.h>
+#include <alibabacloud/core/RoaServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace Sae {
+namespace Model {
+class ALIBABACLOUD_SAE_EXPORT GetWarningEventMetricRequest : public RoaServiceRequest {
+public:
+	GetWarningEventMetricRequest();
+	~GetWarningEventMetricRequest();
+	std::string getAppSource() const;
+	void setAppSource(const std::string &appSource);
+	std::string getCpuStrategy() const;
+	void setCpuStrategy(const std::string &cpuStrategy);
+	std::string getRegionId() const;
+	void setRegionId(const std::string &regionId);
+	long getLimit() const;
+	void setLimit(long limit);
+	long getEndTime() const;
+	void setEndTime(long endTime);
+	long getStartTime() const;
+	void setStartTime(long startTime);
+
+private:
+	std::string appSource_;
+	std::string cpuStrategy_;
+	std::string regionId_;
+	long limit_;
+	long endTime_;
+	long startTime_;
+};
+} // namespace Model
+} // namespace Sae
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_SAE_MODEL_GETWARNINGEVENTMETRICREQUEST_H_

sae/include/alibabacloud/sae/model/GetWarningEventMetricResult.h

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

sae/include/alibabacloud/sae/model/ListApplicationsRequest.h

@@ -30,6 +30,8 @@ class ALIBABACLOUD_SAE_EXPORT ListApplicationsRequest : public RoaServiceRequest
 public:
 	ListApplicationsRequest();
 	~ListApplicationsRequest();
+	std::string getAppSource() const;
+	void setAppSource(const std::string &appSource);
 	std::string getAppName() const;
 	void setAppName(const std::string &appName);
 	std::string getNamespaceId() const;
@@ -50,6 +52,7 @@ public:
 	void setTags(const std::string &tags);
 
 private:
+	std::string appSource_;
 	std::string appName_;
 	std::string namespaceId_;
 	int pageSize_;

sae/include/alibabacloud/sae/model/ListApplicationsResult.h

@@ -42,16 +42,18 @@ namespace AlibabaCloud
 							std::string key;
 						};
 						bool scaleRuleEnabled;
-						int instances;
 						std::string appDescription;
-						std::string appId;
 						int runningInstances;
+						int cpu;
+						std::string scaleRuleType;
+						std::string appName;
+						int instances;
+						std::string appId;
+						int mem;
 						std::string namespaceId;
 						std::string regionId;
 						bool appDeletingStatus;
-						std::string scaleRuleType;
 						std::vector<Application::TagsItem> tags;
-						std::string appName;
 					};
 					std::vector<Application> applications;
 					int pageSize;

sae/include/alibabacloud/sae/model/ListGreyTagRouteResult.h

@@ -52,9 +52,27 @@ namespace AlibabaCloud
 							std::string condition;
 							std::vector<ScRule::Item> items;
 						};
-						struct DubboRule
+						struct AlbRule
 						{
 							struct Item2
+							{
+								std::string type;
+								std::string cond;
+								std::string expr;
+								std::string value;
+								std::string _operator;
+								int index;
+								std::string name;
+							};
+							std::string condition;
+							std::string ingressId;
+							std::string serviceName;
+							std::vector<AlbRule::Item2> items1;
+							std::string serviceId;
+						};
+						struct DubboRule
+						{
+							struct Item4
 							{
 								std::string cond;
 								std::string type;
@@ -69,8 +87,9 @@ namespace AlibabaCloud
 							std::string serviceName;
 							std::string version;
 							std::string methodName;
-							std::vector<DubboRule::Item2> items1;
+							std::vector<DubboRule::Item4> items3;
 						};
+						std::vector<ResultItem::AlbRule> albRules;
 						long greyTagRouteId;
 						std::string description;
 						long createTime;

sae/include/alibabacloud/sae/model/ListIngressesResult.h

@@ -41,12 +41,15 @@ namespace AlibabaCloud
 						std::string description;
 						std::string certIds;
 						std::string certId;
+						std::string mseGatewayProtocol;
+						std::string listenerProtocol;
+						std::string name;
 						std::string loadBalanceType;
+						std::string mseGatewayId;
 						std::string namespaceId;
 						long id;
-						std::string listenerProtocol;
+						std::string mseGatewayPort;
 						std::string slbType;
-						std::string name;
 					};
 					std::vector<Ingress> ingressList;
 				};

sae/include/alibabacloud/sae/model/ListJobsResult.h

@@ -43,10 +43,12 @@ namespace AlibabaCloud
 						};
 						bool scaleRuleEnabled;
 						std::string appDescription;
+						std::string message;
 						long failed;
 						std::string triggerConfig;
 						int runningInstances;
 						bool suspend;
+						int cpu;
 						std::string lastChangeorderState;
 						std::string scaleRuleType;
 						std::string appName;
@@ -54,6 +56,7 @@ namespace AlibabaCloud
 						long succeeded;
 						long active;
 						std::string appId;
+						int mem;
 						long completionTime;
 						std::string lastJobState;
 						long lastStartTime;

sae/include/alibabacloud/sae/model/RestartApplicationRequest.h

@@ -36,11 +36,14 @@ public:
 	void setAppId(const std::string &appId);
 	int getMinReadyInstanceRatio() const;
 	void setMinReadyInstanceRatio(int minReadyInstanceRatio);
+	bool getAutoEnableApplicationScalingRule() const;
+	void setAutoEnableApplicationScalingRule(bool autoEnableApplicationScalingRule);
 
 private:
 	int minReadyInstances_;
 	std::string appId_;
 	int minReadyInstanceRatio_;
+	bool autoEnableApplicationScalingRule_;
 };
 } // namespace Model
 } // namespace Sae

sae/include/alibabacloud/sae/model/UpdateApplicationScalingRuleResult.h

@@ -40,6 +40,8 @@ namespace AlibabaCloud
 						{
 							int targetReplicas;
 							std::string atTime;
+							int minReplicas;
+							int maxReplicas;
 						};
 						std::vector<Schedule> schedules;
 						std::string period;
@@ -50,7 +52,11 @@ namespace AlibabaCloud
 					{
 						struct Metric1
 						{
+							std::string slbId;
 							std::string metricType;
+							std::string vport;
+							std::string slbLogstore;
+							std::string slbProject;
 							int metricTargetAverageUtilization;
 						};
 						std::vector<Metric1> metrics;
@@ -72,14 +78,22 @@ namespace AlibabaCloud
 				UpdateApplicationScalingRuleResult();
 				explicit UpdateApplicationScalingRuleResult(const std::string &payload);
 				~UpdateApplicationScalingRuleResult();
+				std::string getMessage()const;
 				std::string getTraceId()const;
 				Data getData()const;
+				std::string getErrorCode()const;
+				std::string getCode()const;
+				bool getSuccess()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
+				std::string message_;
 				std::string traceId_;
 				Data data_;
+				std::string errorCode_;
+				std::string code_;
+				bool success_;
 
 			};
 		}

sae/include/alibabacloud/sae/model/UpdateGreyTagRouteRequest.h

@@ -36,6 +36,8 @@ public:
 	void setDescription(const std::string &description);
 	std::string getDubboRules() const;
 	void setDubboRules(const std::string &dubboRules);
+	std::string getAlbRules() const;
+	void setAlbRules(const std::string &albRules);
 	std::string getScRules() const;
 	void setScRules(const std::string &scRules);
 
@@ -43,6 +45,7 @@ private:
 	long greyTagRouteId_;
 	std::string description_;
 	std::string dubboRules_;
+	std::string albRules_;
 	std::string scRules_;
 };
 } // namespace Model

sae/include/alibabacloud/sae/model/UpdateNamespaceRequest.h

@@ -34,13 +34,19 @@ public:
 	void setNamespaceName(const std::string &namespaceName);
 	std::string getNamespaceDescription() const;
 	void setNamespaceDescription(const std::string &namespaceDescription);
+	bool getEnableMicroRegistration() const;
+	void setEnableMicroRegistration(bool enableMicroRegistration);
 	std::string getNamespaceId() const;
 	void setNamespaceId(const std::string &namespaceId);
+	std::string getNameSpaceShortId() const;
+	void setNameSpaceShortId(const std::string &nameSpaceShortId);
 
 private:
 	std::string namespaceName_;
 	std::string namespaceDescription_;
+	bool enableMicroRegistration_;
 	std::string namespaceId_;
+	std::string nameSpaceShortId_;
 };
 } // namespace Model
 } // namespace Sae

sae/include/alibabacloud/sae/model/UpdateNamespaceResult.h

@@ -34,10 +34,12 @@ namespace AlibabaCloud
 			public:
 				struct Data
 				{
+					std::string nameSpaceShortId;
 					std::string namespaceName;
 					std::string namespaceId;
 					std::string regionId;
 					std::string namespaceDescription;
+					bool enableMicroRegistration;
 				};
 
 

sae/include/alibabacloud/sae/model/UpdateNamespaceVpcRequest.h

@@ -34,10 +34,13 @@ public:
 	void setNamespaceId(const std::string &namespaceId);
 	std::string getVpcId() const;
 	void setVpcId(const std::string &vpcId);
+	std::string getNameSpaceShortId() const;
+	void setNameSpaceShortId(const std::string &nameSpaceShortId);
 
 private:
 	std::string namespaceId_;
 	std::string vpcId_;
+	std::string nameSpaceShortId_;
 };
 } // namespace Model
 } // namespace Sae

sae/src/SaeClient.cc

@@ -2031,6 +2031,186 @@ SaeClient::ExecJobOutcomeCallable SaeClient::execJobCallable(const ExecJobReques
 	return task->get_future();
 }
 
+SaeClient::GetArmsTopNMetricOutcome SaeClient::getArmsTopNMetric(const GetArmsTopNMetricRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetArmsTopNMetricOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetArmsTopNMetricOutcome(GetArmsTopNMetricResult(outcome.result()));
+	else
+		return GetArmsTopNMetricOutcome(outcome.error());
+}
+
+void SaeClient::getArmsTopNMetricAsync(const GetArmsTopNMetricRequest& request, const GetArmsTopNMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getArmsTopNMetric(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SaeClient::GetArmsTopNMetricOutcomeCallable SaeClient::getArmsTopNMetricCallable(const GetArmsTopNMetricRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetArmsTopNMetricOutcome()>>(
+			[this, request]()
+			{
+			return this->getArmsTopNMetric(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SaeClient::GetAvailabilityMetricOutcome SaeClient::getAvailabilityMetric(const GetAvailabilityMetricRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetAvailabilityMetricOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetAvailabilityMetricOutcome(GetAvailabilityMetricResult(outcome.result()));
+	else
+		return GetAvailabilityMetricOutcome(outcome.error());
+}
+
+void SaeClient::getAvailabilityMetricAsync(const GetAvailabilityMetricRequest& request, const GetAvailabilityMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getAvailabilityMetric(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SaeClient::GetAvailabilityMetricOutcomeCallable SaeClient::getAvailabilityMetricCallable(const GetAvailabilityMetricRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetAvailabilityMetricOutcome()>>(
+			[this, request]()
+			{
+			return this->getAvailabilityMetric(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SaeClient::GetChangeOrderMetricOutcome SaeClient::getChangeOrderMetric(const GetChangeOrderMetricRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetChangeOrderMetricOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetChangeOrderMetricOutcome(GetChangeOrderMetricResult(outcome.result()));
+	else
+		return GetChangeOrderMetricOutcome(outcome.error());
+}
+
+void SaeClient::getChangeOrderMetricAsync(const GetChangeOrderMetricRequest& request, const GetChangeOrderMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getChangeOrderMetric(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SaeClient::GetChangeOrderMetricOutcomeCallable SaeClient::getChangeOrderMetricCallable(const GetChangeOrderMetricRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetChangeOrderMetricOutcome()>>(
+			[this, request]()
+			{
+			return this->getChangeOrderMetric(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SaeClient::GetScaleAppMetricOutcome SaeClient::getScaleAppMetric(const GetScaleAppMetricRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetScaleAppMetricOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetScaleAppMetricOutcome(GetScaleAppMetricResult(outcome.result()));
+	else
+		return GetScaleAppMetricOutcome(outcome.error());
+}
+
+void SaeClient::getScaleAppMetricAsync(const GetScaleAppMetricRequest& request, const GetScaleAppMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getScaleAppMetric(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SaeClient::GetScaleAppMetricOutcomeCallable SaeClient::getScaleAppMetricCallable(const GetScaleAppMetricRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetScaleAppMetricOutcome()>>(
+			[this, request]()
+			{
+			return this->getScaleAppMetric(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+SaeClient::GetWarningEventMetricOutcome SaeClient::getWarningEventMetric(const GetWarningEventMetricRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetWarningEventMetricOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetWarningEventMetricOutcome(GetWarningEventMetricResult(outcome.result()));
+	else
+		return GetWarningEventMetricOutcome(outcome.error());
+}
+
+void SaeClient::getWarningEventMetricAsync(const GetWarningEventMetricRequest& request, const GetWarningEventMetricAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getWarningEventMetric(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+SaeClient::GetWarningEventMetricOutcomeCallable SaeClient::getWarningEventMetricCallable(const GetWarningEventMetricRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetWarningEventMetricOutcome()>>(
+			[this, request]()
+			{
+			return this->getWarningEventMetric(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 SaeClient::ListAppEventsOutcome SaeClient::listAppEvents(const ListAppEventsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

sae/src/model/BatchStartApplicationsRequest.cc

@@ -44,3 +44,12 @@ void BatchStartApplicationsRequest::setNamespaceId(const std::string &namespaceI
   setParameter(std::string("NamespaceId"), namespaceId);
 }
 
+std::string BatchStartApplicationsRequest::getVersion() const {
+  return version_;
+}
+
+void BatchStartApplicationsRequest::setVersion(const std::string &version) {
+  version_ = version;
+  setParameter(std::string("Version"), version);
+}
+

sae/src/model/BatchStopApplicationsRequest.cc

@@ -44,3 +44,12 @@ void BatchStopApplicationsRequest::setNamespaceId(const std::string &namespaceId
   setParameter(std::string("NamespaceId"), namespaceId);
 }
 
+std::string BatchStopApplicationsRequest::getVersion() const {
+  return version_;
+}
+
+void BatchStopApplicationsRequest::setVersion(const std::string &version) {
+  version_ = version;
+  setParameter(std::string("Version"), version);
+}
+

sae/src/model/CreateApplicationRequest.cc

@@ -170,6 +170,15 @@ void CreateApplicationRequest::setPurchaseEip(bool purchaseEip) {
   setParameter(std::string("PurchaseEip"), purchaseEip ? "true" : "false");
 }
 
+std::string CreateApplicationRequest::getSaeVersion() const {
+  return saeVersion_;
+}
+
+void CreateApplicationRequest::setSaeVersion(const std::string &saeVersion) {
+  saeVersion_ = saeVersion;
+  setParameter(std::string("SaeVersion"), saeVersion);
+}
+
 std::string CreateApplicationRequest::getPvtzDiscoverySvc() const {
   return pvtzDiscoverySvc_;
 }
@@ -242,6 +251,15 @@ void CreateApplicationRequest::setVSwitchId(const std::string &vSwitchId) {
   setParameter(std::string("VSwitchId"), vSwitchId);
 }
 
+std::string CreateApplicationRequest::getEnableEbpf() const {
+  return enableEbpf_;
+}
+
+void CreateApplicationRequest::setEnableEbpf(const std::string &enableEbpf) {
+  enableEbpf_ = enableEbpf;
+  setParameter(std::string("EnableEbpf"), enableEbpf);
+}
+
 std::string CreateApplicationRequest::getPackageType() const {
   return packageType_;
 }
@@ -278,6 +296,15 @@ void CreateApplicationRequest::setAssociateEip(bool associateEip) {
   setBodyParameter(std::string("AssociateEip"), associateEip ? "true" : "false");
 }
 
+std::string CreateApplicationRequest::getAppSource() const {
+  return appSource_;
+}
+
+void CreateApplicationRequest::setAppSource(const std::string &appSource) {
+  appSource_ = appSource;
+  setParameter(std::string("AppSource"), appSource);
+}
+
 std::string CreateApplicationRequest::getWebContainer() const {
   return webContainer_;
 }

sae/src/model/CreateApplicationScalingRuleResult.cc

@@ -69,6 +69,10 @@ void CreateApplicationScalingRuleResult::parse(const std::string &payload)
 			scheduleObject.atTime = timerNodeSchedulesSchedule["AtTime"].asString();
 		if(!timerNodeSchedulesSchedule["TargetReplicas"].isNull())
 			scheduleObject.targetReplicas = std::stoi(timerNodeSchedulesSchedule["TargetReplicas"].asString());
+		if(!timerNodeSchedulesSchedule["MaxReplicas"].isNull())
+			scheduleObject.maxReplicas = std::stoi(timerNodeSchedulesSchedule["MaxReplicas"].asString());
+		if(!timerNodeSchedulesSchedule["MinReplicas"].isNull())
+			scheduleObject.minReplicas = std::stoi(timerNodeSchedulesSchedule["MinReplicas"].asString());
 		data_.timer.schedules.push_back(scheduleObject);
 	}
 	auto metricNode = dataNode["Metric"];
@@ -84,13 +88,34 @@ void CreateApplicationScalingRuleResult::parse(const std::string &payload)
 			metric1Object.metricTargetAverageUtilization = std::stoi(metricNodeMetricsMetric["MetricTargetAverageUtilization"].asString());
 		if(!metricNodeMetricsMetric["MetricType"].isNull())
 			metric1Object.metricType = metricNodeMetricsMetric["MetricType"].asString();
+		if(!metricNodeMetricsMetric["SlbProject"].isNull())
+			metric1Object.slbProject = metricNodeMetricsMetric["SlbProject"].asString();
+		if(!metricNodeMetricsMetric["SlbLogstore"].isNull())
+			metric1Object.slbLogstore = metricNodeMetricsMetric["SlbLogstore"].asString();
+		if(!metricNodeMetricsMetric["Vport"].isNull())
+			metric1Object.vport = metricNodeMetricsMetric["Vport"].asString();
+		if(!metricNodeMetricsMetric["SlbId"].isNull())
+			metric1Object.slbId = metricNodeMetricsMetric["SlbId"].asString();
 		data_.metric.metrics.push_back(metric1Object);
 	}
 	if(!value["TraceId"].isNull())
 		traceId_ = value["TraceId"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 
+std::string CreateApplicationScalingRuleResult::getMessage()const
+{
+	return message_;
+}
+
 std::string CreateApplicationScalingRuleResult::getTraceId()const
 {
 	return traceId_;
@@ -101,3 +126,18 @@ CreateApplicationScalingRuleResult::Data CreateApplicationScalingRuleResult::get
 	return data_;
 }
 
+std::string CreateApplicationScalingRuleResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string CreateApplicationScalingRuleResult::getCode()const
+{
+	return code_;
+}
+
+bool CreateApplicationScalingRuleResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/CreateGreyTagRouteRequest.cc

@@ -62,6 +62,15 @@ void CreateGreyTagRouteRequest::setDubboRules(const std::string &dubboRules) {
   setParameter(std::string("DubboRules"), dubboRules);
 }
 
+std::string CreateGreyTagRouteRequest::getAlbRules() const {
+  return albRules_;
+}
+
+void CreateGreyTagRouteRequest::setAlbRules(const std::string &albRules) {
+  albRules_ = albRules;
+  setParameter(std::string("AlbRules"), albRules);
+}
+
 std::string CreateGreyTagRouteRequest::getScRules() const {
   return scRules_;
 }

sae/src/model/CreateNamespaceRequest.cc

@@ -44,6 +44,15 @@ void CreateNamespaceRequest::setNamespaceDescription(const std::string &namespac
   setParameter(std::string("NamespaceDescription"), namespaceDescription);
 }
 
+bool CreateNamespaceRequest::getEnableMicroRegistration() const {
+  return enableMicroRegistration_;
+}
+
+void CreateNamespaceRequest::setEnableMicroRegistration(bool enableMicroRegistration) {
+  enableMicroRegistration_ = enableMicroRegistration;
+  setParameter(std::string("EnableMicroRegistration"), enableMicroRegistration ? "true" : "false");
+}
+
 std::string CreateNamespaceRequest::getNamespaceId() const {
   return namespaceId_;
 }
@@ -53,3 +62,12 @@ void CreateNamespaceRequest::setNamespaceId(const std::string &namespaceId) {
   setParameter(std::string("NamespaceId"), namespaceId);
 }
 
+std::string CreateNamespaceRequest::getNameSpaceShortId() const {
+  return nameSpaceShortId_;
+}
+
+void CreateNamespaceRequest::setNameSpaceShortId(const std::string &nameSpaceShortId) {
+  nameSpaceShortId_ = nameSpaceShortId;
+  setParameter(std::string("NameSpaceShortId"), nameSpaceShortId);
+}
+

sae/src/model/CreateNamespaceResult.cc

@@ -48,6 +48,10 @@ void CreateNamespaceResult::parse(const std::string &payload)
 		data_.namespaceName = dataNode["NamespaceName"].asString();
 	if(!dataNode["RegionId"].isNull())
 		data_.regionId = dataNode["RegionId"].asString();
+	if(!dataNode["NameSpaceShortId"].isNull())
+		data_.nameSpaceShortId = dataNode["NameSpaceShortId"].asString();
+	if(!dataNode["EnableMicroRegistration"].isNull())
+		data_.enableMicroRegistration = dataNode["EnableMicroRegistration"].asString() == "true";
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
 	if(!value["TraceId"].isNull())

sae/src/model/CreateSecretRequest.cc

@@ -50,7 +50,7 @@ std::string CreateSecretRequest::getSecretData() const {
 
 void CreateSecretRequest::setSecretData(const std::string &secretData) {
   secretData_ = secretData;
-  setBodyParameter(std::string("SecretData"), secretData);
+  setParameter(std::string("SecretData"), secretData);
 }
 
 std::string CreateSecretRequest::getSecretName() const {

sae/src/model/DeleteApplicationScalingRuleResult.cc

@@ -41,11 +41,39 @@ void DeleteApplicationScalingRuleResult::parse(const std::string &payload)
 	setRequestId(value["RequestId"].asString());
 	if(!value["TraceId"].isNull())
 		traceId_ = value["TraceId"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 
+std::string DeleteApplicationScalingRuleResult::getMessage()const
+{
+	return message_;
+}
+
 std::string DeleteApplicationScalingRuleResult::getTraceId()const
 {
 	return traceId_;
 }
 
+std::string DeleteApplicationScalingRuleResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string DeleteApplicationScalingRuleResult::getCode()const
+{
+	return code_;
+}
+
+bool DeleteApplicationScalingRuleResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/DeleteNamespaceRequest.cc

@@ -35,3 +35,12 @@ void DeleteNamespaceRequest::setNamespaceId(const std::string &namespaceId) {
   setParameter(std::string("NamespaceId"), namespaceId);
 }
 
+std::string DeleteNamespaceRequest::getNameSpaceShortId() const {
+  return nameSpaceShortId_;
+}
+
+void DeleteNamespaceRequest::setNameSpaceShortId(const std::string &nameSpaceShortId) {
+  nameSpaceShortId_ = nameSpaceShortId;
+  setParameter(std::string("NameSpaceShortId"), nameSpaceShortId);
+}
+

sae/src/model/DeployApplicationRequest.cc

@@ -188,6 +188,15 @@ void DeployApplicationRequest::setPython(const std::string &python) {
   setParameter(std::string("Python"), python);
 }
 
+int DeployApplicationRequest::getCpu() const {
+  return cpu_;
+}
+
+void DeployApplicationRequest::setCpu(int cpu) {
+  cpu_ = cpu;
+  setParameter(std::string("Cpu"), std::to_string(cpu));
+}
+
 std::string DeployApplicationRequest::getUpdateStrategy() const {
   return updateStrategy_;
 }
@@ -197,6 +206,15 @@ void DeployApplicationRequest::setUpdateStrategy(const std::string &updateStrate
   setParameter(std::string("UpdateStrategy"), updateStrategy);
 }
 
+std::string DeployApplicationRequest::getVSwitchId() const {
+  return vSwitchId_;
+}
+
+void DeployApplicationRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
+}
+
 std::string DeployApplicationRequest::getChangeOrderDesc() const {
   return changeOrderDesc_;
 }
@@ -224,6 +242,15 @@ void DeployApplicationRequest::setAutoEnableApplicationScalingRule(bool autoEnab
   setParameter(std::string("AutoEnableApplicationScalingRule"), autoEnableApplicationScalingRule ? "true" : "false");
 }
 
+std::string DeployApplicationRequest::getPackageType() const {
+  return packageType_;
+}
+
+void DeployApplicationRequest::setPackageType(const std::string &packageType) {
+  packageType_ = packageType;
+  setParameter(std::string("PackageType"), packageType);
+}
+
 std::string DeployApplicationRequest::getPostStart() const {
   return postStart_;
 }
@@ -287,6 +314,15 @@ void DeployApplicationRequest::setKafkaConfigs(const std::string &kafkaConfigs)
   setParameter(std::string("KafkaConfigs"), kafkaConfigs);
 }
 
+int DeployApplicationRequest::getMemory() const {
+  return memory_;
+}
+
+void DeployApplicationRequest::setMemory(int memory) {
+  memory_ = memory;
+  setParameter(std::string("Memory"), std::to_string(memory));
+}
+
 std::string DeployApplicationRequest::getCommandArgs() const {
   return commandArgs_;
 }
@@ -341,6 +377,15 @@ void DeployApplicationRequest::setLiveness(const std::string &liveness) {
   setParameter(std::string("Liveness"), liveness);
 }
 
+std::string DeployApplicationRequest::getSecurityGroupId() const {
+  return securityGroupId_;
+}
+
+void DeployApplicationRequest::setSecurityGroupId(const std::string &securityGroupId) {
+  securityGroupId_ = securityGroupId;
+  setParameter(std::string("SecurityGroupId"), securityGroupId);
+}
+
 std::string DeployApplicationRequest::getPackageVersion() const {
   return packageVersion_;
 }
@@ -440,6 +485,15 @@ void DeployApplicationRequest::setEnableGreyTagRoute(bool enableGreyTagRoute) {
   setParameter(std::string("EnableGreyTagRoute"), enableGreyTagRoute ? "true" : "false");
 }
 
+int DeployApplicationRequest::getReplicas() const {
+  return replicas_;
+}
+
+void DeployApplicationRequest::setReplicas(int replicas) {
+  replicas_ = replicas;
+  setParameter(std::string("Replicas"), std::to_string(replicas));
+}
+
 std::string DeployApplicationRequest::getCommand() const {
   return command_;
 }

sae/src/model/DescribeApplicationConfigResult.cc

@@ -166,6 +166,12 @@ void DescribeApplicationConfigResult::parse(const std::string &payload)
 		data_.python = dataNode["Python"].asString();
 	if(!dataNode["PythonModules"].isNull())
 		data_.pythonModules = dataNode["PythonModules"].asString();
+	if(!dataNode["MseApplicationName"].isNull())
+		data_.mseApplicationName = dataNode["MseApplicationName"].asString();
+	if(!dataNode["SaeVersion"].isNull())
+		data_.saeVersion = dataNode["SaeVersion"].asString();
+	if(!dataNode["AppSource"].isNull())
+		data_.appSource = dataNode["AppSource"].asString();
 	auto allConfigMapMountDescNode = dataNode["ConfigMapMountDesc"]["ConfigMapMountDescItem"];
 	for (auto dataNodeConfigMapMountDescConfigMapMountDescItem : allConfigMapMountDescNode)
 	{

sae/src/model/DescribeApplicationScalingRuleResult.cc

@@ -54,6 +54,10 @@ void DescribeApplicationScalingRuleResult::parse(const std::string &payload)
 		data_.scaleRuleType = dataNode["ScaleRuleType"].asString();
 	if(!dataNode["ScaleRuleName"].isNull())
 		data_.scaleRuleName = dataNode["ScaleRuleName"].asString();
+	if(!dataNode["MinReadyInstances"].isNull())
+		data_.minReadyInstances = std::stoi(dataNode["MinReadyInstances"].asString());
+	if(!dataNode["MinReadyInstanceRatio"].isNull())
+		data_.minReadyInstanceRatio = std::stoi(dataNode["MinReadyInstanceRatio"].asString());
 	auto timerNode = dataNode["Timer"];
 	if(!timerNode["EndDate"].isNull())
 		data_.timer.endDate = timerNode["EndDate"].asString();
@@ -69,6 +73,10 @@ void DescribeApplicationScalingRuleResult::parse(const std::string &payload)
 			scheduleObject.atTime = timerNodeSchedulesSchedule["AtTime"].asString();
 		if(!timerNodeSchedulesSchedule["TargetReplicas"].isNull())
 			scheduleObject.targetReplicas = std::stoi(timerNodeSchedulesSchedule["TargetReplicas"].asString());
+		if(!timerNodeSchedulesSchedule["MinReplicas"].isNull())
+			scheduleObject.minReplicas = std::stoi(timerNodeSchedulesSchedule["MinReplicas"].asString());
+		if(!timerNodeSchedulesSchedule["MaxReplicas"].isNull())
+			scheduleObject.maxReplicas = std::stoi(timerNodeSchedulesSchedule["MaxReplicas"].asString());
 		data_.timer.schedules.push_back(scheduleObject);
 	}
 	auto metricNode = dataNode["Metric"];
@@ -84,6 +92,14 @@ void DescribeApplicationScalingRuleResult::parse(const std::string &payload)
 			metric1Object.metricTargetAverageUtilization = std::stoi(metricNodeMetricsMetric["MetricTargetAverageUtilization"].asString());
 		if(!metricNodeMetricsMetric["MetricType"].isNull())
 			metric1Object.metricType = metricNodeMetricsMetric["MetricType"].asString();
+		if(!metricNodeMetricsMetric["SlbProject"].isNull())
+			metric1Object.slbProject = metricNodeMetricsMetric["SlbProject"].asString();
+		if(!metricNodeMetricsMetric["SlbLogstore"].isNull())
+			metric1Object.slbLogstore = metricNodeMetricsMetric["SlbLogstore"].asString();
+		if(!metricNodeMetricsMetric["Vport"].isNull())
+			metric1Object.vport = metricNodeMetricsMetric["Vport"].asString();
+		if(!metricNodeMetricsMetric["SlbId"].isNull())
+			metric1Object.slbId = metricNodeMetricsMetric["SlbId"].asString();
 		data_.metric.metrics.push_back(metric1Object);
 	}
 	auto metricsStatusNode = metricNode["MetricsStatus"];
@@ -135,9 +151,22 @@ void DescribeApplicationScalingRuleResult::parse(const std::string &payload)
 		data_.metric.scaleDownRules.disabled = scaleDownRulesNode["Disabled"].asString() == "true";
 	if(!value["TraceId"].isNull())
 		traceId_ = value["TraceId"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 
+std::string DescribeApplicationScalingRuleResult::getMessage()const
+{
+	return message_;
+}
+
 std::string DescribeApplicationScalingRuleResult::getTraceId()const
 {
 	return traceId_;
@@ -148,3 +177,18 @@ DescribeApplicationScalingRuleResult::Data DescribeApplicationScalingRuleResult:
 	return data_;
 }
 
+std::string DescribeApplicationScalingRuleResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string DescribeApplicationScalingRuleResult::getCode()const
+{
+	return code_;
+}
+
+bool DescribeApplicationScalingRuleResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/DescribeApplicationScalingRulesResult.cc

@@ -64,6 +64,10 @@ void DescribeApplicationScalingRulesResult::parse(const std::string &payload)
 			applicationScalingRuleObject.scaleRuleType = dataNodeApplicationScalingRulesApplicationScalingRule["ScaleRuleType"].asString();
 		if(!dataNodeApplicationScalingRulesApplicationScalingRule["ScaleRuleName"].isNull())
 			applicationScalingRuleObject.scaleRuleName = dataNodeApplicationScalingRulesApplicationScalingRule["ScaleRuleName"].asString();
+		if(!dataNodeApplicationScalingRulesApplicationScalingRule["MinReadyInstances"].isNull())
+			applicationScalingRuleObject.minReadyInstances = std::stoi(dataNodeApplicationScalingRulesApplicationScalingRule["MinReadyInstances"].asString());
+		if(!dataNodeApplicationScalingRulesApplicationScalingRule["MinReadyInstanceRatio"].isNull())
+			applicationScalingRuleObject.minReadyInstanceRatio = std::stoi(dataNodeApplicationScalingRulesApplicationScalingRule["MinReadyInstanceRatio"].asString());
 		auto timerNode = value["Timer"];
 		if(!timerNode["EndDate"].isNull())
 			applicationScalingRuleObject.timer.endDate = timerNode["EndDate"].asString();
@@ -98,6 +102,14 @@ void DescribeApplicationScalingRulesResult::parse(const std::string &payload)
 				metric1Object.metricTargetAverageUtilization = std::stoi(metricNodeMetricsMetric["MetricTargetAverageUtilization"].asString());
 			if(!metricNodeMetricsMetric["MetricType"].isNull())
 				metric1Object.metricType = metricNodeMetricsMetric["MetricType"].asString();
+			if(!metricNodeMetricsMetric["SlbProject"].isNull())
+				metric1Object.slbProject = metricNodeMetricsMetric["SlbProject"].asString();
+			if(!metricNodeMetricsMetric["SlbLogstore"].isNull())
+				metric1Object.slbLogstore = metricNodeMetricsMetric["SlbLogstore"].asString();
+			if(!metricNodeMetricsMetric["Vport"].isNull())
+				metric1Object.vport = metricNodeMetricsMetric["Vport"].asString();
+			if(!metricNodeMetricsMetric["SlbId"].isNull())
+				metric1Object.slbId = metricNodeMetricsMetric["SlbId"].asString();
 			applicationScalingRuleObject.metric.metrics.push_back(metric1Object);
 		}
 		auto metricsStatusNode = metricNode["MetricsStatus"];
@@ -155,9 +167,22 @@ void DescribeApplicationScalingRulesResult::parse(const std::string &payload)
 	}
 	if(!value["TraceId"].isNull())
 		traceId_ = value["TraceId"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 
+std::string DescribeApplicationScalingRulesResult::getMessage()const
+{
+	return message_;
+}
+
 std::string DescribeApplicationScalingRulesResult::getTraceId()const
 {
 	return traceId_;
@@ -168,3 +193,18 @@ DescribeApplicationScalingRulesResult::Data DescribeApplicationScalingRulesResul
 	return data_;
 }
 
+std::string DescribeApplicationScalingRulesResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string DescribeApplicationScalingRulesResult::getCode()const
+{
+	return code_;
+}
+
+bool DescribeApplicationScalingRulesResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/DescribeConfigurationPriceResult.cc

@@ -65,6 +65,69 @@ void DescribeConfigurationPriceResult::parse(const std::string &payload)
 		auto allRuleIds = orderNode["RuleIds"]["RuleId"];
 		for (auto value : allRuleIds)
 			data_.order.ruleIds.push_back(value.asString());
+	auto requestPriceNode = dataNode["RequestPrice"];
+	auto allRules2Node = requestPriceNode["Rules"]["Rule"];
+	for (auto requestPriceNodeRulesRule : allRules2Node)
+	{
+		Data::RequestPrice::Rule3 rule3Object;
+		if(!requestPriceNodeRulesRule["RuleDescId"].isNull())
+			rule3Object.ruleDescId = std::stol(requestPriceNodeRulesRule["RuleDescId"].asString());
+		if(!requestPriceNodeRulesRule["Name"].isNull())
+			rule3Object.name = requestPriceNodeRulesRule["Name"].asString();
+		data_.requestPrice.rules2.push_back(rule3Object);
+	}
+	auto order1Node = requestPriceNode["Order"];
+	if(!order1Node["OriginalAmount"].isNull())
+		data_.requestPrice.order1.originalAmount = std::stof(order1Node["OriginalAmount"].asString());
+	if(!order1Node["DiscountAmount"].isNull())
+		data_.requestPrice.order1.discountAmount = std::stof(order1Node["DiscountAmount"].asString());
+	if(!order1Node["TradeAmount"].isNull())
+		data_.requestPrice.order1.tradeAmount = std::stof(order1Node["TradeAmount"].asString());
+		auto allRuleIds4 = order1Node["RuleIds"]["RuleId"];
+		for (auto value : allRuleIds4)
+			data_.requestPrice.order1.ruleIds4.push_back(value.asString());
+	auto trafficPriceNode = dataNode["TrafficPrice"];
+	auto allRules6Node = trafficPriceNode["Rules"]["Rule"];
+	for (auto trafficPriceNodeRulesRule : allRules6Node)
+	{
+		Data::TrafficPrice::Rule7 rule7Object;
+		if(!trafficPriceNodeRulesRule["RuleDescId"].isNull())
+			rule7Object.ruleDescId = std::stof(trafficPriceNodeRulesRule["RuleDescId"].asString());
+		if(!trafficPriceNodeRulesRule["Name"].isNull())
+			rule7Object.name = trafficPriceNodeRulesRule["Name"].asString();
+		data_.trafficPrice.rules6.push_back(rule7Object);
+	}
+	auto order5Node = trafficPriceNode["Order"];
+	if(!order5Node["OriginalAmount"].isNull())
+		data_.trafficPrice.order5.originalAmount = std::stof(order5Node["OriginalAmount"].asString());
+	if(!order5Node["DiscountAmount"].isNull())
+		data_.trafficPrice.order5.discountAmount = std::stof(order5Node["DiscountAmount"].asString());
+	if(!order5Node["TradeAmount"].isNull())
+		data_.trafficPrice.order5.tradeAmount = std::stof(order5Node["TradeAmount"].asString());
+		auto allRuleIds8 = order5Node["RuleIds"]["RuleId"];
+		for (auto value : allRuleIds8)
+			data_.trafficPrice.order5.ruleIds8.push_back(value.asString());
+	auto cpuMemPriceNode = dataNode["CpuMemPrice"];
+	auto allRules10Node = cpuMemPriceNode["Rules"]["Rule"];
+	for (auto cpuMemPriceNodeRulesRule : allRules10Node)
+	{
+		Data::CpuMemPrice::Rule11 rule11Object;
+		if(!cpuMemPriceNodeRulesRule["RuleDescId"].isNull())
+			rule11Object.ruleDescId = std::stof(cpuMemPriceNodeRulesRule["RuleDescId"].asString());
+		if(!cpuMemPriceNodeRulesRule["Name"].isNull())
+			rule11Object.name = cpuMemPriceNodeRulesRule["Name"].asString();
+		data_.cpuMemPrice.rules10.push_back(rule11Object);
+	}
+	auto order9Node = cpuMemPriceNode["Order"];
+	if(!order9Node["OriginalAmount"].isNull())
+		data_.cpuMemPrice.order9.originalAmount = std::stof(order9Node["OriginalAmount"].asString());
+	if(!order9Node["DiscountAmount"].isNull())
+		data_.cpuMemPrice.order9.discountAmount = std::stof(order9Node["DiscountAmount"].asString());
+	if(!order9Node["TradeAmount"].isNull())
+		data_.cpuMemPrice.order9.tradeAmount = std::stof(order9Node["TradeAmount"].asString());
+		auto allRuleIds12 = order9Node["RuleIds"]["RuleId"];
+		for (auto value : allRuleIds12)
+			data_.cpuMemPrice.order9.ruleIds12.push_back(value.asString());
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
 	if(!value["TraceId"].isNull())

sae/src/model/DescribeGreyTagRouteResult.cc

@@ -82,6 +82,38 @@ void DescribeGreyTagRouteResult::parse(const std::string &payload)
 		}
 		data_.scRules.push_back(scRuleObject);
 	}
+	auto allAlbRulesNode = dataNode["AlbRules"]["albRule"];
+	for (auto dataNodeAlbRulesalbRule : allAlbRulesNode)
+	{
+		Data::AlbRule albRuleObject;
+		if(!dataNodeAlbRulesalbRule["serviceId"].isNull())
+			albRuleObject.serviceId = dataNodeAlbRulesalbRule["serviceId"].asString();
+		if(!dataNodeAlbRulesalbRule["ingressId"].isNull())
+			albRuleObject.ingressId = dataNodeAlbRulesalbRule["ingressId"].asString();
+		if(!dataNodeAlbRulesalbRule["condition"].isNull())
+			albRuleObject.condition = dataNodeAlbRulesalbRule["condition"].asString();
+		auto allitems1Node = dataNodeAlbRulesalbRule["items"]["Scrulesitem"];
+		for (auto dataNodeAlbRulesalbRuleitemsScrulesitem : allitems1Node)
+		{
+			Data::AlbRule::Scrulesitem2 items1Object;
+			if(!dataNodeAlbRulesalbRuleitemsScrulesitem["type"].isNull())
+				items1Object.type = dataNodeAlbRulesalbRuleitemsScrulesitem["type"].asString();
+			if(!dataNodeAlbRulesalbRuleitemsScrulesitem["name"].isNull())
+				items1Object.name = dataNodeAlbRulesalbRuleitemsScrulesitem["name"].asString();
+			if(!dataNodeAlbRulesalbRuleitemsScrulesitem["operator"].isNull())
+				items1Object._operator = dataNodeAlbRulesalbRuleitemsScrulesitem["operator"].asString();
+			if(!dataNodeAlbRulesalbRuleitemsScrulesitem["value"].isNull())
+				items1Object.value = dataNodeAlbRulesalbRuleitemsScrulesitem["value"].asString();
+			if(!dataNodeAlbRulesalbRuleitemsScrulesitem["cond"].isNull())
+				items1Object.cond = dataNodeAlbRulesalbRuleitemsScrulesitem["cond"].asString();
+			if(!dataNodeAlbRulesalbRuleitemsScrulesitem["index"].isNull())
+				items1Object.index = std::stoi(dataNodeAlbRulesalbRuleitemsScrulesitem["index"].asString());
+			if(!dataNodeAlbRulesalbRuleitemsScrulesitem["expr"].isNull())
+				items1Object.expr = dataNodeAlbRulesalbRuleitemsScrulesitem["expr"].asString();
+			albRuleObject.items1.push_back(items1Object);
+		}
+		data_.albRules.push_back(albRuleObject);
+	}
 	auto allDubboRulesNode = dataNode["DubboRules"]["dubboRule"];
 	for (auto dataNodeDubboRulesdubboRule : allDubboRulesNode)
 	{
@@ -96,25 +128,25 @@ void DescribeGreyTagRouteResult::parse(const std::string &payload)
 			dubboRuleObject.methodName = dataNodeDubboRulesdubboRule["methodName"].asString();
 		if(!dataNodeDubboRulesdubboRule["condition"].isNull())
 			dubboRuleObject.condition = dataNodeDubboRulesdubboRule["condition"].asString();
-		auto allitems1Node = dataNodeDubboRulesdubboRule["items"]["item"];
+		auto allitems3Node = dataNodeDubboRulesdubboRule["items"]["item"];
-		for (auto dataNodeDubboRulesdubboRuleitemsitem : allitems1Node)
+		for (auto dataNodeDubboRulesdubboRuleitemsitem : allitems3Node)
 		{
-			Data::DubboRule::Item items1Object;
+			Data::DubboRule::Item items3Object;
 			if(!dataNodeDubboRulesdubboRuleitemsitem["index"].isNull())
-				items1Object.index = std::stoi(dataNodeDubboRulesdubboRuleitemsitem["index"].asString());
+				items3Object.index = std::stoi(dataNodeDubboRulesdubboRuleitemsitem["index"].asString());
 			if(!dataNodeDubboRulesdubboRuleitemsitem["expr"].isNull())
-				items1Object.expr = dataNodeDubboRulesdubboRuleitemsitem["expr"].asString();
+				items3Object.expr = dataNodeDubboRulesdubboRuleitemsitem["expr"].asString();
 			if(!dataNodeDubboRulesdubboRuleitemsitem["operator"].isNull())
-				items1Object._operator = dataNodeDubboRulesdubboRuleitemsitem["operator"].asString();
+				items3Object._operator = dataNodeDubboRulesdubboRuleitemsitem["operator"].asString();
 			if(!dataNodeDubboRulesdubboRuleitemsitem["value"].isNull())
-				items1Object.value = dataNodeDubboRulesdubboRuleitemsitem["value"].asString();
+				items3Object.value = dataNodeDubboRulesdubboRuleitemsitem["value"].asString();
 			if(!dataNodeDubboRulesdubboRuleitemsitem["cond"].isNull())
-				items1Object.cond = dataNodeDubboRulesdubboRuleitemsitem["cond"].asString();
+				items3Object.cond = dataNodeDubboRulesdubboRuleitemsitem["cond"].asString();
 			if(!dataNodeDubboRulesdubboRuleitemsitem["type"].isNull())
-				items1Object.type = dataNodeDubboRulesdubboRuleitemsitem["type"].asString();
+				items3Object.type = dataNodeDubboRulesdubboRuleitemsitem["type"].asString();
 			if(!dataNodeDubboRulesdubboRuleitemsitem["name"].isNull())
-				items1Object.name = dataNodeDubboRulesdubboRuleitemsitem["name"].asString();
+				items3Object.name = dataNodeDubboRulesdubboRuleitemsitem["name"].asString();
-			dubboRuleObject.items1.push_back(items1Object);
+			dubboRuleObject.items3.push_back(items3Object);
 		}
 		data_.dubboRules.push_back(dubboRuleObject);
 	}

sae/src/model/DescribeIngressResult.cc

@@ -52,8 +52,6 @@ void DescribeIngressResult::parse(const std::string &payload)
 		data_.slbType = dataNode["SlbType"].asString();
 	if(!dataNode["CertId"].isNull())
 		data_.certId = dataNode["CertId"].asString();
-	if(!dataNode["CertIds"].isNull())
-		data_.certIds = dataNode["CertIds"].asString();
 	if(!dataNode["Name"].isNull())
 		data_.name = dataNode["Name"].asString();
 	if(!dataNode["Id"].isNull())
@@ -62,6 +60,8 @@ void DescribeIngressResult::parse(const std::string &payload)
 		data_.loadBalanceType = dataNode["LoadBalanceType"].asString();
 	if(!dataNode["ListenerProtocol"].isNull())
 		data_.listenerProtocol = dataNode["ListenerProtocol"].asString();
+	if(!dataNode["CertIds"].isNull())
+		data_.certIds = dataNode["CertIds"].asString();
 	auto allRulesNode = dataNode["Rules"]["Rule"];
 	for (auto dataNodeRulesRule : allRulesNode)
 	{
@@ -78,8 +78,26 @@ void DescribeIngressResult::parse(const std::string &payload)
 			ruleObject.path = dataNodeRulesRule["Path"].asString();
 		if(!dataNodeRulesRule["BackendProtocol"].isNull())
 			ruleObject.backendProtocol = dataNodeRulesRule["BackendProtocol"].asString();
+		if(!dataNodeRulesRule["RewritePath"].isNull())
+			ruleObject.rewritePath = dataNodeRulesRule["RewritePath"].asString();
 		data_.rules.push_back(ruleObject);
 	}
+	auto allSvcsNode = dataNode["Svcs"]["Svc"];
+	for (auto dataNodeSvcsSvc : allSvcsNode)
+	{
+		Data::Svc svcObject;
+		if(!dataNodeSvcsSvc["id"].isNull())
+			svcObject.id = std::stol(dataNodeSvcsSvc["id"].asString());
+		if(!dataNodeSvcsSvc["appId"].isNull())
+			svcObject.appId = dataNodeSvcsSvc["appId"].asString();
+		if(!dataNodeSvcsSvc["backendProtocol"].isNull())
+			svcObject.backendProtocol = dataNodeSvcsSvc["backendProtocol"].asString();
+		if(!dataNodeSvcsSvc["backendPort"].isNull())
+			svcObject.backendPort = std::stoi(dataNodeSvcsSvc["backendPort"].asString());
+		if(!dataNodeSvcsSvc["name"].isNull())
+			svcObject.name = dataNodeSvcsSvc["name"].asString();
+		data_.svcs.push_back(svcObject);
+	}
 	auto defaultRuleNode = dataNode["DefaultRule"];
 	if(!defaultRuleNode["ContainerPort"].isNull())
 		data_.defaultRule.containerPort = std::stoi(defaultRuleNode["ContainerPort"].asString());

sae/src/model/DescribeNamespaceListResult.cc

@@ -63,6 +63,8 @@ void DescribeNamespaceListResult::parse(const std::string &payload)
 			dataObject.namespaceName = valueDataRegionList["NamespaceName"].asString();
 		if(!valueDataRegionList["RegionId"].isNull())
 			dataObject.regionId = valueDataRegionList["RegionId"].asString();
+		if(!valueDataRegionList["NameSpaceShortId"].isNull())
+			dataObject.nameSpaceShortId = valueDataRegionList["NameSpaceShortId"].asString();
 		data_.push_back(dataObject);
 	}
 	if(!value["Message"].isNull())

sae/src/model/DescribeNamespaceRequest.cc

@@ -35,3 +35,12 @@ void DescribeNamespaceRequest::setNamespaceId(const std::string &namespaceId) {
   setParameter(std::string("NamespaceId"), namespaceId);
 }
 
+std::string DescribeNamespaceRequest::getNameSpaceShortId() const {
+  return nameSpaceShortId_;
+}
+
+void DescribeNamespaceRequest::setNameSpaceShortId(const std::string &nameSpaceShortId) {
+  nameSpaceShortId_ = nameSpaceShortId;
+  setParameter(std::string("NameSpaceShortId"), nameSpaceShortId);
+}
+

sae/src/model/DescribeNamespaceResourcesRequest.cc

@@ -35,3 +35,12 @@ void DescribeNamespaceResourcesRequest::setNamespaceId(const std::string &namesp
   setParameter(std::string("NamespaceId"), namespaceId);
 }
 
+std::string DescribeNamespaceResourcesRequest::getNameSpaceShortId() const {
+  return nameSpaceShortId_;
+}
+
+void DescribeNamespaceResourcesRequest::setNameSpaceShortId(const std::string &nameSpaceShortId) {
+  nameSpaceShortId_ = nameSpaceShortId;
+  setParameter(std::string("NameSpaceShortId"), nameSpaceShortId);
+}
+

sae/src/model/DescribeNamespaceResourcesResult.cc

@@ -76,6 +76,8 @@ void DescribeNamespaceResourcesResult::parse(const std::string &payload)
 		data_.jumpServerAppId = dataNode["JumpServerAppId"].asString();
 	if(!dataNode["JumpServerIp"].isNull())
 		data_.jumpServerIp = dataNode["JumpServerIp"].asString();
+	if(!dataNode["NameSpaceShortId"].isNull())
+		data_.nameSpaceShortId = dataNode["NameSpaceShortId"].asString();
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
 	if(!value["TraceId"].isNull())

sae/src/model/DescribeNamespaceResult.cc

@@ -48,6 +48,10 @@ void DescribeNamespaceResult::parse(const std::string &payload)
 		data_.namespaceName = dataNode["NamespaceName"].asString();
 	if(!dataNode["RegionId"].isNull())
 		data_.regionId = dataNode["RegionId"].asString();
+	if(!dataNode["NameSpaceShortId"].isNull())
+		data_.nameSpaceShortId = dataNode["NameSpaceShortId"].asString();
+	if(!dataNode["EnableMicroRegistration"].isNull())
+		data_.enableMicroRegistration = dataNode["EnableMicroRegistration"].asString() == "true";
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
 	if(!value["TraceId"].isNull())

sae/src/model/DescribeNamespacesResult.cc

@@ -66,6 +66,8 @@ void DescribeNamespacesResult::parse(const std::string &payload)
 			_namespaceObject.tenantId = dataNodeNamespacesNamespace["TenantId"].asString();
 		if(!dataNodeNamespacesNamespace["RegionId"].isNull())
 			_namespaceObject.regionId = dataNodeNamespacesNamespace["RegionId"].asString();
+		if(!dataNodeNamespacesNamespace["NameSpaceShortId"].isNull())
+			_namespaceObject.nameSpaceShortId = dataNodeNamespacesNamespace["NameSpaceShortId"].asString();
 		data_.namespaces.push_back(_namespaceObject);
 	}
 	if(!value["Message"].isNull())

sae/src/model/DescribePipelineResult.cc

@@ -90,6 +90,12 @@ void DescribePipelineResult::parse(const std::string &payload)
 				taskListObject.showManualIgnore = dataNodeStageListStageTaskListTask["ShowManualIgnore"].asString() == "true";
 			if(!dataNodeStageListStageTaskListTask["TaskId"].isNull())
 				taskListObject.taskId = dataNodeStageListStageTaskListTask["TaskId"].asString();
+			if(!dataNodeStageListStageTaskListTask["CreateTime"].isNull())
+				taskListObject.createTime = std::stol(dataNodeStageListStageTaskListTask["CreateTime"].asString());
+			if(!dataNodeStageListStageTaskListTask["StartTime"].isNull())
+				taskListObject.startTime = std::stol(dataNodeStageListStageTaskListTask["StartTime"].asString());
+			if(!dataNodeStageListStageTaskListTask["UpdateTime"].isNull())
+				taskListObject.updateTime = std::stol(dataNodeStageListStageTaskListTask["UpdateTime"].asString());
 			stageObject.taskList.push_back(taskListObject);
 		}
 		data_.stageList.push_back(stageObject);

sae/src/model/DisableApplicationScalingRuleResult.cc

@@ -41,11 +41,39 @@ void DisableApplicationScalingRuleResult::parse(const std::string &payload)
 	setRequestId(value["RequestId"].asString());
 	if(!value["TraceId"].isNull())
 		traceId_ = value["TraceId"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 
+std::string DisableApplicationScalingRuleResult::getMessage()const
+{
+	return message_;
+}
+
 std::string DisableApplicationScalingRuleResult::getTraceId()const
 {
 	return traceId_;
 }
 
+std::string DisableApplicationScalingRuleResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string DisableApplicationScalingRuleResult::getCode()const
+{
+	return code_;
+}
+
+bool DisableApplicationScalingRuleResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/EnableApplicationScalingRuleResult.cc

@@ -41,11 +41,39 @@ void EnableApplicationScalingRuleResult::parse(const std::string &payload)
 	setRequestId(value["RequestId"].asString());
 	if(!value["TraceId"].isNull())
 		traceId_ = value["TraceId"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 
+std::string EnableApplicationScalingRuleResult::getMessage()const
+{
+	return message_;
+}
+
 std::string EnableApplicationScalingRuleResult::getTraceId()const
 {
 	return traceId_;
 }
 
+std::string EnableApplicationScalingRuleResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string EnableApplicationScalingRuleResult::getCode()const
+{
+	return code_;
+}
+
+bool EnableApplicationScalingRuleResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/ExecJobRequest.cc

@@ -62,6 +62,15 @@ void ExecJobRequest::setCommandArgs(const std::string &commandArgs) {
   setParameter(std::string("CommandArgs"), commandArgs);
 }
 
+std::string ExecJobRequest::getReplicas() const {
+  return replicas_;
+}
+
+void ExecJobRequest::setReplicas(const std::string &replicas) {
+  replicas_ = replicas;
+  setParameter(std::string("Replicas"), replicas);
+}
+
 std::string ExecJobRequest::getAppId() const {
   return appId_;
 }

sae/src/model/GetArmsTopNMetricRequest.cc

@@ -0,0 +1,91 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sae/model/GetArmsTopNMetricRequest.h>
+
+using AlibabaCloud::Sae::Model::GetArmsTopNMetricRequest;
+
+GetArmsTopNMetricRequest::GetArmsTopNMetricRequest()
+    : RoaServiceRequest("sae", "2019-05-06") {
+  setResourcePath("/pop/v1/sam/getArmsTopNMetric"};
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetArmsTopNMetricRequest::~GetArmsTopNMetricRequest() {}
+
+std::string GetArmsTopNMetricRequest::getAppSource() const {
+  return appSource_;
+}
+
+void GetArmsTopNMetricRequest::setAppSource(const std::string &appSource) {
+  appSource_ = appSource;
+  setParameter(std::string("AppSource"), appSource);
+}
+
+std::string GetArmsTopNMetricRequest::getCpuStrategy() const {
+  return cpuStrategy_;
+}
+
+void GetArmsTopNMetricRequest::setCpuStrategy(const std::string &cpuStrategy) {
+  cpuStrategy_ = cpuStrategy;
+  setParameter(std::string("CpuStrategy"), cpuStrategy);
+}
+
+std::string GetArmsTopNMetricRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetArmsTopNMetricRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+long GetArmsTopNMetricRequest::getLimit() const {
+  return limit_;
+}
+
+void GetArmsTopNMetricRequest::setLimit(long limit) {
+  limit_ = limit;
+  setParameter(std::string("Limit"), std::to_string(limit));
+}
+
+std::string GetArmsTopNMetricRequest::getOrderBy() const {
+  return orderBy_;
+}
+
+void GetArmsTopNMetricRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
+}
+
+long GetArmsTopNMetricRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetArmsTopNMetricRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+long GetArmsTopNMetricRequest::getStartTime() const {
+  return startTime_;
+}
+
+void GetArmsTopNMetricRequest::setStartTime(long startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), std::to_string(startTime));
+}
+

sae/src/model/GetArmsTopNMetricResult.cc

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/sae/model/GetArmsTopNMetricResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Sae;
+using namespace AlibabaCloud::Sae::Model;
+
+GetArmsTopNMetricResult::GetArmsTopNMetricResult() :
+	ServiceResult()
+{}
+
+GetArmsTopNMetricResult::GetArmsTopNMetricResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetArmsTopNMetricResult::~GetArmsTopNMetricResult()
+{}
+
+void GetArmsTopNMetricResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["ArmsMetricDto"];
+	for (auto valueDataArmsMetricDto : allDataNode)
+	{
+		ArmsMetricDto dataObject;
+		if(!valueDataArmsMetricDto["AppId"].isNull())
+			dataObject.appId = valueDataArmsMetricDto["AppId"].asString();
+		if(!valueDataArmsMetricDto["Name"].isNull())
+			dataObject.name = valueDataArmsMetricDto["Name"].asString();
+		if(!valueDataArmsMetricDto["RegionId"].isNull())
+			dataObject.regionId = valueDataArmsMetricDto["RegionId"].asString();
+		if(!valueDataArmsMetricDto["Count"].isNull())
+			dataObject.count = std::stol(valueDataArmsMetricDto["Count"].asString());
+		if(!valueDataArmsMetricDto["Error"].isNull())
+			dataObject.error = std::stol(valueDataArmsMetricDto["Error"].asString());
+		if(!valueDataArmsMetricDto["Rt"].isNull())
+			dataObject.rt = std::stol(valueDataArmsMetricDto["Rt"].asString());
+		data_.push_back(dataObject);
+	}
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string GetArmsTopNMetricResult::getMessage()const
+{
+	return message_;
+}
+
+std::vector<GetArmsTopNMetricResult::ArmsMetricDto> GetArmsTopNMetricResult::getData()const
+{
+	return data_;
+}
+
+std::string GetArmsTopNMetricResult::getCode()const
+{
+	return code_;
+}
+
+bool GetArmsTopNMetricResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/GetAvailabilityMetricRequest.cc

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sae/model/GetAvailabilityMetricRequest.h>
+
+using AlibabaCloud::Sae::Model::GetAvailabilityMetricRequest;
+
+GetAvailabilityMetricRequest::GetAvailabilityMetricRequest()
+    : RoaServiceRequest("sae", "2019-05-06") {
+  setResourcePath("/pop/v1/sam/getAvailabilityMetric"};
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetAvailabilityMetricRequest::~GetAvailabilityMetricRequest() {}
+
+std::string GetAvailabilityMetricRequest::getAppSource() const {
+  return appSource_;
+}
+
+void GetAvailabilityMetricRequest::setAppSource(const std::string &appSource) {
+  appSource_ = appSource;
+  setParameter(std::string("AppSource"), appSource);
+}
+
+std::string GetAvailabilityMetricRequest::getCpuStrategy() const {
+  return cpuStrategy_;
+}
+
+void GetAvailabilityMetricRequest::setCpuStrategy(const std::string &cpuStrategy) {
+  cpuStrategy_ = cpuStrategy;
+  setParameter(std::string("CpuStrategy"), cpuStrategy);
+}
+
+std::string GetAvailabilityMetricRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetAvailabilityMetricRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+long GetAvailabilityMetricRequest::getLimit() const {
+  return limit_;
+}
+
+void GetAvailabilityMetricRequest::setLimit(long limit) {
+  limit_ = limit;
+  setParameter(std::string("Limit"), std::to_string(limit));
+}
+

sae/src/model/GetAvailabilityMetricResult.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/sae/model/GetAvailabilityMetricResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Sae;
+using namespace AlibabaCloud::Sae::Model;
+
+GetAvailabilityMetricResult::GetAvailabilityMetricResult() :
+	ServiceResult()
+{}
+
+GetAvailabilityMetricResult::GetAvailabilityMetricResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetAvailabilityMetricResult::~GetAvailabilityMetricResult()
+{}
+
+void GetAvailabilityMetricResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["AvailabilityMetricDto"];
+	for (auto valueDataAvailabilityMetricDto : allDataNode)
+	{
+		AvailabilityMetricDto dataObject;
+		if(!valueDataAvailabilityMetricDto["AppId"].isNull())
+			dataObject.appId = valueDataAvailabilityMetricDto["AppId"].asString();
+		if(!valueDataAvailabilityMetricDto["Name"].isNull())
+			dataObject.name = valueDataAvailabilityMetricDto["Name"].asString();
+		if(!valueDataAvailabilityMetricDto["RegionId"].isNull())
+			dataObject.regionId = valueDataAvailabilityMetricDto["RegionId"].asString();
+		if(!valueDataAvailabilityMetricDto["Runnings"].isNull())
+			dataObject.runnings = std::stol(valueDataAvailabilityMetricDto["Runnings"].asString());
+		if(!valueDataAvailabilityMetricDto["Instances"].isNull())
+			dataObject.instances = std::stol(valueDataAvailabilityMetricDto["Instances"].asString());
+		if(!valueDataAvailabilityMetricDto["ErrorInstances"].isNull())
+			dataObject.errorInstances = std::stol(valueDataAvailabilityMetricDto["ErrorInstances"].asString());
+		if(!valueDataAvailabilityMetricDto["EnableAutoscale"].isNull())
+			dataObject.enableAutoscale = std::stol(valueDataAvailabilityMetricDto["EnableAutoscale"].asString());
+		data_.push_back(dataObject);
+	}
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string GetAvailabilityMetricResult::getMessage()const
+{
+	return message_;
+}
+
+std::vector<GetAvailabilityMetricResult::AvailabilityMetricDto> GetAvailabilityMetricResult::getData()const
+{
+	return data_;
+}
+
+std::string GetAvailabilityMetricResult::getCode()const
+{
+	return code_;
+}
+
+bool GetAvailabilityMetricResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/GetChangeOrderMetricRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sae/model/GetChangeOrderMetricRequest.h>
+
+using AlibabaCloud::Sae::Model::GetChangeOrderMetricRequest;
+
+GetChangeOrderMetricRequest::GetChangeOrderMetricRequest()
+    : RoaServiceRequest("sae", "2019-05-06") {
+  setResourcePath("/pop/v1/sam/getChangeOrderMetric"};
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetChangeOrderMetricRequest::~GetChangeOrderMetricRequest() {}
+
+std::string GetChangeOrderMetricRequest::getAppSource() const {
+  return appSource_;
+}
+
+void GetChangeOrderMetricRequest::setAppSource(const std::string &appSource) {
+  appSource_ = appSource;
+  setParameter(std::string("AppSource"), appSource);
+}
+
+std::string GetChangeOrderMetricRequest::getCreateTime() const {
+  return createTime_;
+}
+
+void GetChangeOrderMetricRequest::setCreateTime(const std::string &createTime) {
+  createTime_ = createTime;
+  setParameter(std::string("CreateTime"), createTime);
+}
+
+std::string GetChangeOrderMetricRequest::getCpuStrategy() const {
+  return cpuStrategy_;
+}
+
+void GetChangeOrderMetricRequest::setCpuStrategy(const std::string &cpuStrategy) {
+  cpuStrategy_ = cpuStrategy;
+  setParameter(std::string("CpuStrategy"), cpuStrategy);
+}
+
+std::string GetChangeOrderMetricRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetChangeOrderMetricRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+long GetChangeOrderMetricRequest::getLimit() const {
+  return limit_;
+}
+
+void GetChangeOrderMetricRequest::setLimit(long limit) {
+  limit_ = limit;
+  setParameter(std::string("Limit"), std::to_string(limit));
+}
+
+std::string GetChangeOrderMetricRequest::getOrderBy() const {
+  return orderBy_;
+}
+
+void GetChangeOrderMetricRequest::setOrderBy(const std::string &orderBy) {
+  orderBy_ = orderBy;
+  setParameter(std::string("OrderBy"), orderBy);
+}
+

sae/src/model/GetChangeOrderMetricResult.cc

@@ -0,0 +1,88 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/sae/model/GetChangeOrderMetricResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Sae;
+using namespace AlibabaCloud::Sae::Model;
+
+GetChangeOrderMetricResult::GetChangeOrderMetricResult() :
+	ServiceResult()
+{}
+
+GetChangeOrderMetricResult::GetChangeOrderMetricResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetChangeOrderMetricResult::~GetChangeOrderMetricResult()
+{}
+
+void GetChangeOrderMetricResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["ChangeOrderMetricDto"];
+	for (auto valueDataChangeOrderMetricDto : allDataNode)
+	{
+		ChangeOrderMetricDto dataObject;
+		if(!valueDataChangeOrderMetricDto["AppId"].isNull())
+			dataObject.appId = valueDataChangeOrderMetricDto["AppId"].asString();
+		if(!valueDataChangeOrderMetricDto["Name"].isNull())
+			dataObject.name = valueDataChangeOrderMetricDto["Name"].asString();
+		if(!valueDataChangeOrderMetricDto["RegionId"].isNull())
+			dataObject.regionId = valueDataChangeOrderMetricDto["RegionId"].asString();
+		if(!valueDataChangeOrderMetricDto["Total"].isNull())
+			dataObject.total = std::stol(valueDataChangeOrderMetricDto["Total"].asString());
+		if(!valueDataChangeOrderMetricDto["Error"].isNull())
+			dataObject.error = std::stol(valueDataChangeOrderMetricDto["Error"].asString());
+		if(!valueDataChangeOrderMetricDto["ErrorPercent"].isNull())
+			dataObject.errorPercent = std::stof(valueDataChangeOrderMetricDto["ErrorPercent"].asString());
+		data_.push_back(dataObject);
+	}
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string GetChangeOrderMetricResult::getMessage()const
+{
+	return message_;
+}
+
+std::vector<GetChangeOrderMetricResult::ChangeOrderMetricDto> GetChangeOrderMetricResult::getData()const
+{
+	return data_;
+}
+
+std::string GetChangeOrderMetricResult::getCode()const
+{
+	return code_;
+}
+
+bool GetChangeOrderMetricResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/GetScaleAppMetricRequest.cc

@@ -0,0 +1,64 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sae/model/GetScaleAppMetricRequest.h>
+
+using AlibabaCloud::Sae::Model::GetScaleAppMetricRequest;
+
+GetScaleAppMetricRequest::GetScaleAppMetricRequest()
+    : RoaServiceRequest("sae", "2019-05-06") {
+  setResourcePath("/pop/v1/sam/getScaleAppMetric"};
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetScaleAppMetricRequest::~GetScaleAppMetricRequest() {}
+
+std::string GetScaleAppMetricRequest::getAppSource() const {
+  return appSource_;
+}
+
+void GetScaleAppMetricRequest::setAppSource(const std::string &appSource) {
+  appSource_ = appSource;
+  setParameter(std::string("AppSource"), appSource);
+}
+
+std::string GetScaleAppMetricRequest::getCpuStrategy() const {
+  return cpuStrategy_;
+}
+
+void GetScaleAppMetricRequest::setCpuStrategy(const std::string &cpuStrategy) {
+  cpuStrategy_ = cpuStrategy;
+  setParameter(std::string("CpuStrategy"), cpuStrategy);
+}
+
+std::string GetScaleAppMetricRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetScaleAppMetricRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+long GetScaleAppMetricRequest::getLimit() const {
+  return limit_;
+}
+
+void GetScaleAppMetricRequest::setLimit(long limit) {
+  limit_ = limit;
+  setParameter(std::string("Limit"), std::to_string(limit));
+}
+

sae/src/model/GetScaleAppMetricResult.cc

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT 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/sae/model/GetScaleAppMetricResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Sae;
+using namespace AlibabaCloud::Sae::Model;
+
+GetScaleAppMetricResult::GetScaleAppMetricResult() :
+	ServiceResult()
+{}
+
+GetScaleAppMetricResult::GetScaleAppMetricResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetScaleAppMetricResult::~GetScaleAppMetricResult()
+{}
+
+void GetScaleAppMetricResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["ScaleAppMetricDto"];
+	for (auto valueDataScaleAppMetricDto : allDataNode)
+	{
+		ScaleAppMetricDto dataObject;
+		if(!valueDataScaleAppMetricDto["AppId"].isNull())
+			dataObject.appId = valueDataScaleAppMetricDto["AppId"].asString();
+		if(!valueDataScaleAppMetricDto["Name"].isNull())
+			dataObject.name = valueDataScaleAppMetricDto["Name"].asString();
+		if(!valueDataScaleAppMetricDto["RegionId"].isNull())
+			dataObject.regionId = valueDataScaleAppMetricDto["RegionId"].asString();
+		if(!valueDataScaleAppMetricDto["Runnings"].isNull())
+			dataObject.runnings = std::stol(valueDataScaleAppMetricDto["Runnings"].asString());
+		if(!valueDataScaleAppMetricDto["MaxReplicas"].isNull())
+			dataObject.maxReplicas = std::stol(valueDataScaleAppMetricDto["MaxReplicas"].asString());
+		data_.push_back(dataObject);
+	}
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string GetScaleAppMetricResult::getMessage()const
+{
+	return message_;
+}
+
+std::vector<GetScaleAppMetricResult::ScaleAppMetricDto> GetScaleAppMetricResult::getData()const
+{
+	return data_;
+}
+
+std::string GetScaleAppMetricResult::getCode()const
+{
+	return code_;
+}
+
+bool GetScaleAppMetricResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/GetWarningEventMetricRequest.cc

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sae/model/GetWarningEventMetricRequest.h>
+
+using AlibabaCloud::Sae::Model::GetWarningEventMetricRequest;
+
+GetWarningEventMetricRequest::GetWarningEventMetricRequest()
+    : RoaServiceRequest("sae", "2019-05-06") {
+  setResourcePath("/pop/v1/sam/getWarningEventMetric"};
+  setMethod(HttpRequest::Method::Get);
+}
+
+GetWarningEventMetricRequest::~GetWarningEventMetricRequest() {}
+
+std::string GetWarningEventMetricRequest::getAppSource() const {
+  return appSource_;
+}
+
+void GetWarningEventMetricRequest::setAppSource(const std::string &appSource) {
+  appSource_ = appSource;
+  setParameter(std::string("AppSource"), appSource);
+}
+
+std::string GetWarningEventMetricRequest::getCpuStrategy() const {
+  return cpuStrategy_;
+}
+
+void GetWarningEventMetricRequest::setCpuStrategy(const std::string &cpuStrategy) {
+  cpuStrategy_ = cpuStrategy;
+  setParameter(std::string("CpuStrategy"), cpuStrategy);
+}
+
+std::string GetWarningEventMetricRequest::getRegionId() const {
+  return regionId_;
+}
+
+void GetWarningEventMetricRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+long GetWarningEventMetricRequest::getLimit() const {
+  return limit_;
+}
+
+void GetWarningEventMetricRequest::setLimit(long limit) {
+  limit_ = limit;
+  setParameter(std::string("Limit"), std::to_string(limit));
+}
+
+long GetWarningEventMetricRequest::getEndTime() const {
+  return endTime_;
+}
+
+void GetWarningEventMetricRequest::setEndTime(long endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), std::to_string(endTime));
+}
+
+long GetWarningEventMetricRequest::getStartTime() const {
+  return startTime_;
+}
+
+void GetWarningEventMetricRequest::setStartTime(long startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), std::to_string(startTime));
+}
+

sae/src/model/GetWarningEventMetricResult.cc

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/sae/model/GetWarningEventMetricResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Sae;
+using namespace AlibabaCloud::Sae::Model;
+
+GetWarningEventMetricResult::GetWarningEventMetricResult() :
+	ServiceResult()
+{}
+
+GetWarningEventMetricResult::GetWarningEventMetricResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetWarningEventMetricResult::~GetWarningEventMetricResult()
+{}
+
+void GetWarningEventMetricResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["EventMetricDto"];
+	for (auto valueDataEventMetricDto : allDataNode)
+	{
+		EventMetricDto dataObject;
+		if(!valueDataEventMetricDto["AppId"].isNull())
+			dataObject.appId = valueDataEventMetricDto["AppId"].asString();
+		if(!valueDataEventMetricDto["Name"].isNull())
+			dataObject.name = valueDataEventMetricDto["Name"].asString();
+		if(!valueDataEventMetricDto["RegionId"].isNull())
+			dataObject.regionId = valueDataEventMetricDto["RegionId"].asString();
+		if(!valueDataEventMetricDto["WarningCount"].isNull())
+			dataObject.warningCount = std::stol(valueDataEventMetricDto["WarningCount"].asString());
+		data_.push_back(dataObject);
+	}
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
+
+}
+
+std::string GetWarningEventMetricResult::getMessage()const
+{
+	return message_;
+}
+
+std::vector<GetWarningEventMetricResult::EventMetricDto> GetWarningEventMetricResult::getData()const
+{
+	return data_;
+}
+
+std::string GetWarningEventMetricResult::getCode()const
+{
+	return code_;
+}
+
+bool GetWarningEventMetricResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/ListApplicationsRequest.cc

@@ -26,6 +26,15 @@ ListApplicationsRequest::ListApplicationsRequest()
 
 ListApplicationsRequest::~ListApplicationsRequest() {}
 
+std::string ListApplicationsRequest::getAppSource() const {
+  return appSource_;
+}
+
+void ListApplicationsRequest::setAppSource(const std::string &appSource) {
+  appSource_ = appSource;
+  setParameter(std::string("AppSource"), appSource);
+}
+
 std::string ListApplicationsRequest::getAppName() const {
   return appName_;
 }

sae/src/model/ListApplicationsResult.cc

@@ -70,6 +70,10 @@ void ListApplicationsResult::parse(const std::string &payload)
 			applicationObject.regionId = dataNodeApplicationsApplication["RegionId"].asString();
 		if(!dataNodeApplicationsApplication["AppDescription"].isNull())
 			applicationObject.appDescription = dataNodeApplicationsApplication["AppDescription"].asString();
+		if(!dataNodeApplicationsApplication["Cpu"].isNull())
+			applicationObject.cpu = std::stoi(dataNodeApplicationsApplication["Cpu"].asString());
+		if(!dataNodeApplicationsApplication["Mem"].isNull())
+			applicationObject.mem = std::stoi(dataNodeApplicationsApplication["Mem"].asString());
 		auto allTagsNode = dataNodeApplicationsApplication["Tags"]["TagsItem"];
 		for (auto dataNodeApplicationsApplicationTagsTagsItem : allTagsNode)
 		{

sae/src/model/ListGreyTagRouteResult.cc

@@ -90,6 +90,40 @@ void ListGreyTagRouteResult::parse(const std::string &payload)
 			}
 			resultItemObject.scRules.push_back(scRulesObject);
 		}
+		auto allAlbRulesNode = dataNodeResultresultItem["AlbRules"]["albRule"];
+		for (auto dataNodeResultresultItemAlbRulesalbRule : allAlbRulesNode)
+		{
+			Data::ResultItem::AlbRule albRulesObject;
+			if(!dataNodeResultresultItemAlbRulesalbRule["serviceId"].isNull())
+				albRulesObject.serviceId = dataNodeResultresultItemAlbRulesalbRule["serviceId"].asString();
+			if(!dataNodeResultresultItemAlbRulesalbRule["ingressId"].isNull())
+				albRulesObject.ingressId = dataNodeResultresultItemAlbRulesalbRule["ingressId"].asString();
+			if(!dataNodeResultresultItemAlbRulesalbRule["condition"].isNull())
+				albRulesObject.condition = dataNodeResultresultItemAlbRulesalbRule["condition"].asString();
+			if(!dataNodeResultresultItemAlbRulesalbRule["serviceName"].isNull())
+				albRulesObject.serviceName = dataNodeResultresultItemAlbRulesalbRule["serviceName"].asString();
+			auto allitems1Node = dataNodeResultresultItemAlbRulesalbRule["items"]["item"];
+			for (auto dataNodeResultresultItemAlbRulesalbRuleitemsitem : allitems1Node)
+			{
+				Data::ResultItem::AlbRule::Item2 items1Object;
+				if(!dataNodeResultresultItemAlbRulesalbRuleitemsitem["type"].isNull())
+					items1Object.type = dataNodeResultresultItemAlbRulesalbRuleitemsitem["type"].asString();
+				if(!dataNodeResultresultItemAlbRulesalbRuleitemsitem["name"].isNull())
+					items1Object.name = dataNodeResultresultItemAlbRulesalbRuleitemsitem["name"].asString();
+				if(!dataNodeResultresultItemAlbRulesalbRuleitemsitem["operator"].isNull())
+					items1Object._operator = dataNodeResultresultItemAlbRulesalbRuleitemsitem["operator"].asString();
+				if(!dataNodeResultresultItemAlbRulesalbRuleitemsitem["value"].isNull())
+					items1Object.value = dataNodeResultresultItemAlbRulesalbRuleitemsitem["value"].asString();
+				if(!dataNodeResultresultItemAlbRulesalbRuleitemsitem["cond"].isNull())
+					items1Object.cond = dataNodeResultresultItemAlbRulesalbRuleitemsitem["cond"].asString();
+				if(!dataNodeResultresultItemAlbRulesalbRuleitemsitem["index"].isNull())
+					items1Object.index = std::stoi(dataNodeResultresultItemAlbRulesalbRuleitemsitem["index"].asString());
+				if(!dataNodeResultresultItemAlbRulesalbRuleitemsitem["expr"].isNull())
+					items1Object.expr = dataNodeResultresultItemAlbRulesalbRuleitemsitem["expr"].asString();
+				albRulesObject.items1.push_back(items1Object);
+			}
+			resultItemObject.albRules.push_back(albRulesObject);
+		}
 		auto allDubboRulesNode = dataNodeResultresultItem["DubboRules"]["dubboRule"];
 		for (auto dataNodeResultresultItemDubboRulesdubboRule : allDubboRulesNode)
 		{
@@ -104,25 +138,25 @@ void ListGreyTagRouteResult::parse(const std::string &payload)
 				dubboRulesObject.methodName = dataNodeResultresultItemDubboRulesdubboRule["methodName"].asString();
 			if(!dataNodeResultresultItemDubboRulesdubboRule["condition"].isNull())
 				dubboRulesObject.condition = dataNodeResultresultItemDubboRulesdubboRule["condition"].asString();
-			auto allitems1Node = dataNodeResultresultItemDubboRulesdubboRule["items"]["item"];
+			auto allitems3Node = dataNodeResultresultItemDubboRulesdubboRule["items"]["item"];
-			for (auto dataNodeResultresultItemDubboRulesdubboRuleitemsitem : allitems1Node)
+			for (auto dataNodeResultresultItemDubboRulesdubboRuleitemsitem : allitems3Node)
 			{
-				Data::ResultItem::DubboRule::Item2 items1Object;
+				Data::ResultItem::DubboRule::Item4 items3Object;
 				if(!dataNodeResultresultItemDubboRulesdubboRuleitemsitem["index"].isNull())
-					items1Object.index = std::stoi(dataNodeResultresultItemDubboRulesdubboRuleitemsitem["index"].asString());
+					items3Object.index = std::stoi(dataNodeResultresultItemDubboRulesdubboRuleitemsitem["index"].asString());
 				if(!dataNodeResultresultItemDubboRulesdubboRuleitemsitem["expr"].isNull())
-					items1Object.expr = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["expr"].asString();
+					items3Object.expr = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["expr"].asString();
 				if(!dataNodeResultresultItemDubboRulesdubboRuleitemsitem["operator"].isNull())
-					items1Object._operator = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["operator"].asString();
+					items3Object._operator = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["operator"].asString();
 				if(!dataNodeResultresultItemDubboRulesdubboRuleitemsitem["value"].isNull())
-					items1Object.value = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["value"].asString();
+					items3Object.value = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["value"].asString();
 				if(!dataNodeResultresultItemDubboRulesdubboRuleitemsitem["cond"].isNull())
-					items1Object.cond = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["cond"].asString();
+					items3Object.cond = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["cond"].asString();
 				if(!dataNodeResultresultItemDubboRulesdubboRuleitemsitem["type"].isNull())
-					items1Object.type = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["type"].asString();
+					items3Object.type = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["type"].asString();
 				if(!dataNodeResultresultItemDubboRulesdubboRuleitemsitem["name"].isNull())
-					items1Object.name = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["name"].asString();
+					items3Object.name = dataNodeResultresultItemDubboRulesdubboRuleitemsitem["name"].asString();
-				dubboRulesObject.items1.push_back(items1Object);
+				dubboRulesObject.items3.push_back(items3Object);
 			}
 			resultItemObject.dubboRules.push_back(dubboRulesObject);
 		}

sae/src/model/ListIngressesResult.cc

@@ -66,6 +66,12 @@ void ListIngressesResult::parse(const std::string &payload)
 			ingressObject.loadBalanceType = dataNodeIngressListIngress["LoadBalanceType"].asString();
 		if(!dataNodeIngressListIngress["ListenerProtocol"].isNull())
 			ingressObject.listenerProtocol = dataNodeIngressListIngress["ListenerProtocol"].asString();
+		if(!dataNodeIngressListIngress["MseGatewayId"].isNull())
+			ingressObject.mseGatewayId = dataNodeIngressListIngress["MseGatewayId"].asString();
+		if(!dataNodeIngressListIngress["MseGatewayPort"].isNull())
+			ingressObject.mseGatewayPort = dataNodeIngressListIngress["MseGatewayPort"].asString();
+		if(!dataNodeIngressListIngress["MseGatewayProtocol"].isNull())
+			ingressObject.mseGatewayProtocol = dataNodeIngressListIngress["MseGatewayProtocol"].asString();
 		data_.ingressList.push_back(ingressObject);
 	}
 	if(!value["Message"].isNull())

sae/src/model/ListJobsResult.cc

@@ -88,6 +88,12 @@ void ListJobsResult::parse(const std::string &payload)
 			applicationObject.lastChangeorderState = dataNodeApplicationsApplication["LastChangeorderState"].asString();
 		if(!dataNodeApplicationsApplication["LastJobState"].isNull())
 			applicationObject.lastJobState = dataNodeApplicationsApplication["LastJobState"].asString();
+		if(!dataNodeApplicationsApplication["Cpu"].isNull())
+			applicationObject.cpu = std::stoi(dataNodeApplicationsApplication["Cpu"].asString());
+		if(!dataNodeApplicationsApplication["Mem"].isNull())
+			applicationObject.mem = std::stoi(dataNodeApplicationsApplication["Mem"].asString());
+		if(!dataNodeApplicationsApplication["Message"].isNull())
+			applicationObject.message = dataNodeApplicationsApplication["Message"].asString();
 		auto allTagsNode = dataNodeApplicationsApplication["Tags"]["TagsItem"];
 		for (auto dataNodeApplicationsApplicationTagsTagsItem : allTagsNode)
 		{

sae/src/model/RestartApplicationRequest.cc

@@ -53,3 +53,12 @@ void RestartApplicationRequest::setMinReadyInstanceRatio(int minReadyInstanceRat
   setParameter(std::string("MinReadyInstanceRatio"), std::to_string(minReadyInstanceRatio));
 }
 
+bool RestartApplicationRequest::getAutoEnableApplicationScalingRule() const {
+  return autoEnableApplicationScalingRule_;
+}
+
+void RestartApplicationRequest::setAutoEnableApplicationScalingRule(bool autoEnableApplicationScalingRule) {
+  autoEnableApplicationScalingRule_ = autoEnableApplicationScalingRule;
+  setParameter(std::string("AutoEnableApplicationScalingRule"), autoEnableApplicationScalingRule ? "true" : "false");
+}
+

sae/src/model/UpdateApplicationScalingRuleResult.cc

@@ -69,6 +69,10 @@ void UpdateApplicationScalingRuleResult::parse(const std::string &payload)
 			scheduleObject.atTime = timerNodeSchedulesSchedule["AtTime"].asString();
 		if(!timerNodeSchedulesSchedule["TargetReplicas"].isNull())
 			scheduleObject.targetReplicas = std::stoi(timerNodeSchedulesSchedule["TargetReplicas"].asString());
+		if(!timerNodeSchedulesSchedule["MinReplicas"].isNull())
+			scheduleObject.minReplicas = std::stoi(timerNodeSchedulesSchedule["MinReplicas"].asString());
+		if(!timerNodeSchedulesSchedule["MaxReplicas"].isNull())
+			scheduleObject.maxReplicas = std::stoi(timerNodeSchedulesSchedule["MaxReplicas"].asString());
 		data_.timer.schedules.push_back(scheduleObject);
 	}
 	auto metricNode = dataNode["Metric"];
@@ -84,13 +88,34 @@ void UpdateApplicationScalingRuleResult::parse(const std::string &payload)
 			metric1Object.metricTargetAverageUtilization = std::stoi(metricNodeMetricsMetric["MetricTargetAverageUtilization"].asString());
 		if(!metricNodeMetricsMetric["MetricType"].isNull())
 			metric1Object.metricType = metricNodeMetricsMetric["MetricType"].asString();
+		if(!metricNodeMetricsMetric["SlbProject"].isNull())
+			metric1Object.slbProject = metricNodeMetricsMetric["SlbProject"].asString();
+		if(!metricNodeMetricsMetric["SlbLogstore"].isNull())
+			metric1Object.slbLogstore = metricNodeMetricsMetric["SlbLogstore"].asString();
+		if(!metricNodeMetricsMetric["Vport"].isNull())
+			metric1Object.vport = metricNodeMetricsMetric["Vport"].asString();
+		if(!metricNodeMetricsMetric["SlbId"].isNull())
+			metric1Object.slbId = metricNodeMetricsMetric["SlbId"].asString();
 		data_.metric.metrics.push_back(metric1Object);
 	}
 	if(!value["TraceId"].isNull())
 		traceId_ = value["TraceId"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+	if(!value["ErrorCode"].isNull())
+		errorCode_ = value["ErrorCode"].asString();
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Success"].isNull())
+		success_ = value["Success"].asString() == "true";
 
 }
 
+std::string UpdateApplicationScalingRuleResult::getMessage()const
+{
+	return message_;
+}
+
 std::string UpdateApplicationScalingRuleResult::getTraceId()const
 {
 	return traceId_;
@@ -101,3 +126,18 @@ UpdateApplicationScalingRuleResult::Data UpdateApplicationScalingRuleResult::get
 	return data_;
 }
 
+std::string UpdateApplicationScalingRuleResult::getErrorCode()const
+{
+	return errorCode_;
+}
+
+std::string UpdateApplicationScalingRuleResult::getCode()const
+{
+	return code_;
+}
+
+bool UpdateApplicationScalingRuleResult::getSuccess()const
+{
+	return success_;
+}
+

sae/src/model/UpdateGreyTagRouteRequest.cc

@@ -53,6 +53,15 @@ void UpdateGreyTagRouteRequest::setDubboRules(const std::string &dubboRules) {
   setParameter(std::string("DubboRules"), dubboRules);
 }
 
+std::string UpdateGreyTagRouteRequest::getAlbRules() const {
+  return albRules_;
+}
+
+void UpdateGreyTagRouteRequest::setAlbRules(const std::string &albRules) {
+  albRules_ = albRules;
+  setParameter(std::string("AlbRules"), albRules);
+}
+
 std::string UpdateGreyTagRouteRequest::getScRules() const {
   return scRules_;
 }

sae/src/model/UpdateNamespaceRequest.cc

@@ -44,6 +44,15 @@ void UpdateNamespaceRequest::setNamespaceDescription(const std::string &namespac
   setParameter(std::string("NamespaceDescription"), namespaceDescription);
 }
 
+bool UpdateNamespaceRequest::getEnableMicroRegistration() const {
+  return enableMicroRegistration_;
+}
+
+void UpdateNamespaceRequest::setEnableMicroRegistration(bool enableMicroRegistration) {
+  enableMicroRegistration_ = enableMicroRegistration;
+  setParameter(std::string("EnableMicroRegistration"), enableMicroRegistration ? "true" : "false");
+}
+
 std::string UpdateNamespaceRequest::getNamespaceId() const {
   return namespaceId_;
 }
@@ -53,3 +62,12 @@ void UpdateNamespaceRequest::setNamespaceId(const std::string &namespaceId) {
   setParameter(std::string("NamespaceId"), namespaceId);
 }
 
+std::string UpdateNamespaceRequest::getNameSpaceShortId() const {
+  return nameSpaceShortId_;
+}
+
+void UpdateNamespaceRequest::setNameSpaceShortId(const std::string &nameSpaceShortId) {
+  nameSpaceShortId_ = nameSpaceShortId;
+  setParameter(std::string("NameSpaceShortId"), nameSpaceShortId);
+}
+

sae/src/model/UpdateNamespaceResult.cc

@@ -48,6 +48,10 @@ void UpdateNamespaceResult::parse(const std::string &payload)
 		data_.namespaceName = dataNode["NamespaceName"].asString();
 	if(!dataNode["RegionId"].isNull())
 		data_.regionId = dataNode["RegionId"].asString();
+	if(!dataNode["NameSpaceShortId"].isNull())
+		data_.nameSpaceShortId = dataNode["NameSpaceShortId"].asString();
+	if(!dataNode["EnableMicroRegistration"].isNull())
+		data_.enableMicroRegistration = dataNode["EnableMicroRegistration"].asString() == "true";
 	if(!value["Message"].isNull())
 		message_ = value["Message"].asString();
 	if(!value["TraceId"].isNull())

sae/src/model/UpdateNamespaceVpcRequest.cc

@@ -44,3 +44,12 @@ void UpdateNamespaceVpcRequest::setVpcId(const std::string &vpcId) {
   setParameter(std::string("VpcId"), vpcId);
 }
 
+std::string UpdateNamespaceVpcRequest::getNameSpaceShortId() const {
+  return nameSpaceShortId_;
+}
+
+void UpdateNamespaceVpcRequest::setNameSpaceShortId(const std::string &nameSpaceShortId) {
+  nameSpaceShortId_ = nameSpaceShortId;
+  setParameter(std::string("NameSpaceShortId"), nameSpaceShortId);
+}
+

sae/src/model/UpdateSecretRequest.cc

@@ -50,6 +50,6 @@ std::string UpdateSecretRequest::getSecretData() const {
 
 void UpdateSecretRequest::setSecretData(const std::string &secretData) {
   secretData_ = secretData;
-  setBodyParameter(std::string("SecretData"), secretData);
+  setParameter(std::string("SecretData"), secretData);
 }