Support attribute filtering for DescribeInstanceTypes.

VERSION

@@ -1 +1 @@
-1.36.1249
+1.36.1250

ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesRequest.h

@@ -30,32 +30,131 @@ class ALIBABACLOUD_ECS_EXPORT DescribeInstanceTypesRequest : public RpcServiceRe
 public:
 	DescribeInstanceTypesRequest();
 	~DescribeInstanceTypesRequest();
+	std::string getGPUSpec() const;
+	void setGPUSpec(const std::string &gPUSpec);
 	long getResourceOwnerId() const;
 	void setResourceOwnerId(long resourceOwnerId);
+	int getMaximumCpuCoreCount() const;
+	void setMaximumCpuCoreCount(int maximumCpuCoreCount);
+	int getMaximumGPUAmount() const;
+	void setMaximumGPUAmount(int maximumGPUAmount);
+	std::string getLocalStorageCategory() const;
+	void setLocalStorageCategory(const std::string &localStorageCategory);
+	float getMaximumMemorySize() const;
+	void setMaximumMemorySize(float maximumMemorySize);
+	std::string getInstanceCategory() const;
+	void setInstanceCategory(const std::string &instanceCategory);
+	long getMinimumInstancePpsTx() const;
+	void setMinimumInstancePpsTx(long minimumInstancePpsTx);
+	int getMinimumCpuCoreCount() const;
+	void setMinimumCpuCoreCount(int minimumCpuCoreCount);
+	int getMinimumPrimaryEniQueueNumber() const;
+	void setMinimumPrimaryEniQueueNumber(int minimumPrimaryEniQueueNumber);
+	int getMinimumBaselineCredit() const;
+	void setMinimumBaselineCredit(int minimumBaselineCredit);
+	int getMinimumSecondaryEniQueueNumber() const;
+	void setMinimumSecondaryEniQueueNumber(int minimumSecondaryEniQueueNumber);
+	int getMinimumInstanceBandwidthTx() const;
+	void setMinimumInstanceBandwidthTx(int minimumInstanceBandwidthTx);
+	int getMinimumGPUAmount() const;
+	void setMinimumGPUAmount(int minimumGPUAmount);
+	float getMaximumCpuSpeedFrequency() const;
+	void setMaximumCpuSpeedFrequency(float maximumCpuSpeedFrequency);
+	std::string getCpuArchitecture() const;
+	void setCpuArchitecture(const std::string &cpuArchitecture);
+	long getOwnerId() const;
+	void setOwnerId(long ownerId);
+	float getMinimumMemorySize() const;
+	void setMinimumMemorySize(float minimumMemorySize);
+	int getMinimumEniQuantity() const;
+	void setMinimumEniQuantity(int minimumEniQuantity);
+	std::string getInstanceFamilyLevel() const;
+	void setInstanceFamilyLevel(const std::string &instanceFamilyLevel);
+	int getMinimumQueuePairNumber() const;
+	void setMinimumQueuePairNumber(int minimumQueuePairNumber);
+	int getMinimumLocalStorageAmount() const;
+	void setMinimumLocalStorageAmount(int minimumLocalStorageAmount);
+	long getMaxResults() const;
+	void setMaxResults(long maxResults);
+	std::string getPhysicalProcessorModel() const;
+	void setPhysicalProcessorModel(const std::string &physicalProcessorModel);
+	float getMaximumCpuTurboFrequency() const;
+	void setMaximumCpuTurboFrequency(float maximumCpuTurboFrequency);
 	std::vector<std::string> getInstanceTypes() const;
 	void setInstanceTypes(const std::vector<std::string> &instanceTypes);
+	long getMinimumInstancePpsRx() const;
+	void setMinimumInstancePpsRx(long minimumInstancePpsRx);
+	int getMinimumEniIpv6AddressQuantity() const;
+	void setMinimumEniIpv6AddressQuantity(int minimumEniIpv6AddressQuantity);
+	int getMinimumEriQuantity() const;
+	void setMinimumEriQuantity(int minimumEriQuantity);
+	int getMinimumDiskQuantity() const;
+	void setMinimumDiskQuantity(int minimumDiskQuantity);
+	float getMinimumCpuTurboFrequency() const;
+	void setMinimumCpuTurboFrequency(float minimumCpuTurboFrequency);
 	std::string getNextToken() const;
 	void setNextToken(const std::string &nextToken);
+	int getMinimumInstanceBandwidthRx() const;
+	void setMinimumInstanceBandwidthRx(int minimumInstanceBandwidthRx);
+	float getMinimumCpuSpeedFrequency() const;
+	void setMinimumCpuSpeedFrequency(float minimumCpuSpeedFrequency);
+	std::string getNvmeSupport() const;
+	void setNvmeSupport(const std::string &nvmeSupport);
 	std::string getResourceOwnerAccount() const;
 	void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
 	std::string getOwnerAccount() const;
 	void setOwnerAccount(const std::string &ownerAccount);
+	int getMinimumInitialCredit() const;
+	void setMinimumInitialCredit(int minimumInitialCredit);
 	std::string getInstanceTypeFamily() const;
 	void setInstanceTypeFamily(const std::string &instanceTypeFamily);
-	long getOwnerId() const;
-	void setOwnerId(long ownerId);
-	long getMaxResults() const;
-	void setMaxResults(long maxResults);
+	int getMinimumEniPrivateIpAddressQuantity() const;
+	void setMinimumEniPrivateIpAddressQuantity(int minimumEniPrivateIpAddressQuantity);
+	long getMinimumLocalStorageCapacity() const;
+	void setMinimumLocalStorageCapacity(long minimumLocalStorageCapacity);
 
 private:
+	std::string gPUSpec_;
 	long resourceOwnerId_;
+	int maximumCpuCoreCount_;
+	int maximumGPUAmount_;
+	std::string localStorageCategory_;
+	float maximumMemorySize_;
+	std::string instanceCategory_;
+	long minimumInstancePpsTx_;
+	int minimumCpuCoreCount_;
+	int minimumPrimaryEniQueueNumber_;
+	int minimumBaselineCredit_;
+	int minimumSecondaryEniQueueNumber_;
+	int minimumInstanceBandwidthTx_;
+	int minimumGPUAmount_;
+	float maximumCpuSpeedFrequency_;
+	std::string cpuArchitecture_;
+	long ownerId_;
+	float minimumMemorySize_;
+	int minimumEniQuantity_;
+	std::string instanceFamilyLevel_;
+	int minimumQueuePairNumber_;
+	int minimumLocalStorageAmount_;
+	long maxResults_;
+	std::string physicalProcessorModel_;
+	float maximumCpuTurboFrequency_;
 	std::vector<std::string> instanceTypes_;
+	long minimumInstancePpsRx_;
+	int minimumEniIpv6AddressQuantity_;
+	int minimumEriQuantity_;
+	int minimumDiskQuantity_;
+	float minimumCpuTurboFrequency_;
 	std::string nextToken_;
+	int minimumInstanceBandwidthRx_;
+	float minimumCpuSpeedFrequency_;
+	std::string nvmeSupport_;
 	std::string resourceOwnerAccount_;
 	std::string ownerAccount_;
+	int minimumInitialCredit_;
 	std::string instanceTypeFamily_;
-	long ownerId_;
-	long maxResults_;
+	int minimumEniPrivateIpAddressQuantity_;
+	long minimumLocalStorageCapacity_;
 };
 } // namespace Model
 } // namespace Ecs

ecs/include/alibabacloud/ecs/model/DescribeInstanceTypesResult.h

@@ -42,13 +42,16 @@ namespace AlibabaCloud
 					bool eniTrunkSupported;
 					std::string instanceTypeFamily;
 					long instancePpsRx;
+					bool networkEncryptionSupport;
 					int eriQuantity;
 					int instanceBandwidthRx;
 					int instanceBandwidthTx;
 					int localStorageAmount;
 					int secondaryEniQueueNumber;
+					std::string physicalProcessorModel;
 					std::string localStorageCategory;
 					std::string gPUSpec;
+					std::string cpuArchitecture;
 					std::string instanceTypeId;
 					float memorySize;
 					int maximumQueueNumberPerEni;
@@ -56,12 +59,15 @@ namespace AlibabaCloud
 					int eniTotalQuantity;
 					int cpuCoreCount;
 					int initialCredit;
+					std::string instanceCategory;
 					int eniQuantity;
 					int gPUAmount;
 					int diskQuantity;
+					float cpuSpeedFrequency;
 					int queuePairNumber;
 					int baselineCredit;
 					std::string instanceFamilyLevel;
+					float cpuTurboFrequency;
 					int eniPrivateIpAddressQuantity;
 				};
 

ecs/src/model/DescribeInstanceTypesRequest.cc

@@ -25,6 +25,15 @@ DescribeInstanceTypesRequest::DescribeInstanceTypesRequest()
 
 DescribeInstanceTypesRequest::~DescribeInstanceTypesRequest() {}
 
+std::string DescribeInstanceTypesRequest::getGPUSpec() const {
+  return gPUSpec_;
+}
+
+void DescribeInstanceTypesRequest::setGPUSpec(const std::string &gPUSpec) {
+  gPUSpec_ = gPUSpec;
+  setParameter(std::string("GPUSpec"), gPUSpec);
+}
+
 long DescribeInstanceTypesRequest::getResourceOwnerId() const {
   return resourceOwnerId_;
 }
@@ -34,6 +43,213 @@ void DescribeInstanceTypesRequest::setResourceOwnerId(long resourceOwnerId) {
   setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
+int DescribeInstanceTypesRequest::getMaximumCpuCoreCount() const {
+  return maximumCpuCoreCount_;
+}
+
+void DescribeInstanceTypesRequest::setMaximumCpuCoreCount(int maximumCpuCoreCount) {
+  maximumCpuCoreCount_ = maximumCpuCoreCount;
+  setParameter(std::string("MaximumCpuCoreCount"), std::to_string(maximumCpuCoreCount));
+}
+
+int DescribeInstanceTypesRequest::getMaximumGPUAmount() const {
+  return maximumGPUAmount_;
+}
+
+void DescribeInstanceTypesRequest::setMaximumGPUAmount(int maximumGPUAmount) {
+  maximumGPUAmount_ = maximumGPUAmount;
+  setParameter(std::string("MaximumGPUAmount"), std::to_string(maximumGPUAmount));
+}
+
+std::string DescribeInstanceTypesRequest::getLocalStorageCategory() const {
+  return localStorageCategory_;
+}
+
+void DescribeInstanceTypesRequest::setLocalStorageCategory(const std::string &localStorageCategory) {
+  localStorageCategory_ = localStorageCategory;
+  setParameter(std::string("LocalStorageCategory"), localStorageCategory);
+}
+
+float DescribeInstanceTypesRequest::getMaximumMemorySize() const {
+  return maximumMemorySize_;
+}
+
+void DescribeInstanceTypesRequest::setMaximumMemorySize(float maximumMemorySize) {
+  maximumMemorySize_ = maximumMemorySize;
+  setParameter(std::string("MaximumMemorySize"), std::to_string(maximumMemorySize));
+}
+
+std::string DescribeInstanceTypesRequest::getInstanceCategory() const {
+  return instanceCategory_;
+}
+
+void DescribeInstanceTypesRequest::setInstanceCategory(const std::string &instanceCategory) {
+  instanceCategory_ = instanceCategory;
+  setParameter(std::string("InstanceCategory"), instanceCategory);
+}
+
+long DescribeInstanceTypesRequest::getMinimumInstancePpsTx() const {
+  return minimumInstancePpsTx_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumInstancePpsTx(long minimumInstancePpsTx) {
+  minimumInstancePpsTx_ = minimumInstancePpsTx;
+  setParameter(std::string("MinimumInstancePpsTx"), std::to_string(minimumInstancePpsTx));
+}
+
+int DescribeInstanceTypesRequest::getMinimumCpuCoreCount() const {
+  return minimumCpuCoreCount_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumCpuCoreCount(int minimumCpuCoreCount) {
+  minimumCpuCoreCount_ = minimumCpuCoreCount;
+  setParameter(std::string("MinimumCpuCoreCount"), std::to_string(minimumCpuCoreCount));
+}
+
+int DescribeInstanceTypesRequest::getMinimumPrimaryEniQueueNumber() const {
+  return minimumPrimaryEniQueueNumber_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumPrimaryEniQueueNumber(int minimumPrimaryEniQueueNumber) {
+  minimumPrimaryEniQueueNumber_ = minimumPrimaryEniQueueNumber;
+  setParameter(std::string("MinimumPrimaryEniQueueNumber"), std::to_string(minimumPrimaryEniQueueNumber));
+}
+
+int DescribeInstanceTypesRequest::getMinimumBaselineCredit() const {
+  return minimumBaselineCredit_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumBaselineCredit(int minimumBaselineCredit) {
+  minimumBaselineCredit_ = minimumBaselineCredit;
+  setParameter(std::string("MinimumBaselineCredit"), std::to_string(minimumBaselineCredit));
+}
+
+int DescribeInstanceTypesRequest::getMinimumSecondaryEniQueueNumber() const {
+  return minimumSecondaryEniQueueNumber_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumSecondaryEniQueueNumber(int minimumSecondaryEniQueueNumber) {
+  minimumSecondaryEniQueueNumber_ = minimumSecondaryEniQueueNumber;
+  setParameter(std::string("MinimumSecondaryEniQueueNumber"), std::to_string(minimumSecondaryEniQueueNumber));
+}
+
+int DescribeInstanceTypesRequest::getMinimumInstanceBandwidthTx() const {
+  return minimumInstanceBandwidthTx_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumInstanceBandwidthTx(int minimumInstanceBandwidthTx) {
+  minimumInstanceBandwidthTx_ = minimumInstanceBandwidthTx;
+  setParameter(std::string("MinimumInstanceBandwidthTx"), std::to_string(minimumInstanceBandwidthTx));
+}
+
+int DescribeInstanceTypesRequest::getMinimumGPUAmount() const {
+  return minimumGPUAmount_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumGPUAmount(int minimumGPUAmount) {
+  minimumGPUAmount_ = minimumGPUAmount;
+  setParameter(std::string("MinimumGPUAmount"), std::to_string(minimumGPUAmount));
+}
+
+float DescribeInstanceTypesRequest::getMaximumCpuSpeedFrequency() const {
+  return maximumCpuSpeedFrequency_;
+}
+
+void DescribeInstanceTypesRequest::setMaximumCpuSpeedFrequency(float maximumCpuSpeedFrequency) {
+  maximumCpuSpeedFrequency_ = maximumCpuSpeedFrequency;
+  setParameter(std::string("MaximumCpuSpeedFrequency"), std::to_string(maximumCpuSpeedFrequency));
+}
+
+std::string DescribeInstanceTypesRequest::getCpuArchitecture() const {
+  return cpuArchitecture_;
+}
+
+void DescribeInstanceTypesRequest::setCpuArchitecture(const std::string &cpuArchitecture) {
+  cpuArchitecture_ = cpuArchitecture;
+  setParameter(std::string("CpuArchitecture"), cpuArchitecture);
+}
+
+long DescribeInstanceTypesRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeInstanceTypesRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+float DescribeInstanceTypesRequest::getMinimumMemorySize() const {
+  return minimumMemorySize_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumMemorySize(float minimumMemorySize) {
+  minimumMemorySize_ = minimumMemorySize;
+  setParameter(std::string("MinimumMemorySize"), std::to_string(minimumMemorySize));
+}
+
+int DescribeInstanceTypesRequest::getMinimumEniQuantity() const {
+  return minimumEniQuantity_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumEniQuantity(int minimumEniQuantity) {
+  minimumEniQuantity_ = minimumEniQuantity;
+  setParameter(std::string("MinimumEniQuantity"), std::to_string(minimumEniQuantity));
+}
+
+std::string DescribeInstanceTypesRequest::getInstanceFamilyLevel() const {
+  return instanceFamilyLevel_;
+}
+
+void DescribeInstanceTypesRequest::setInstanceFamilyLevel(const std::string &instanceFamilyLevel) {
+  instanceFamilyLevel_ = instanceFamilyLevel;
+  setParameter(std::string("InstanceFamilyLevel"), instanceFamilyLevel);
+}
+
+int DescribeInstanceTypesRequest::getMinimumQueuePairNumber() const {
+  return minimumQueuePairNumber_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumQueuePairNumber(int minimumQueuePairNumber) {
+  minimumQueuePairNumber_ = minimumQueuePairNumber;
+  setParameter(std::string("MinimumQueuePairNumber"), std::to_string(minimumQueuePairNumber));
+}
+
+int DescribeInstanceTypesRequest::getMinimumLocalStorageAmount() const {
+  return minimumLocalStorageAmount_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumLocalStorageAmount(int minimumLocalStorageAmount) {
+  minimumLocalStorageAmount_ = minimumLocalStorageAmount;
+  setParameter(std::string("MinimumLocalStorageAmount"), std::to_string(minimumLocalStorageAmount));
+}
+
+long DescribeInstanceTypesRequest::getMaxResults() const {
+  return maxResults_;
+}
+
+void DescribeInstanceTypesRequest::setMaxResults(long maxResults) {
+  maxResults_ = maxResults;
+  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+}
+
+std::string DescribeInstanceTypesRequest::getPhysicalProcessorModel() const {
+  return physicalProcessorModel_;
+}
+
+void DescribeInstanceTypesRequest::setPhysicalProcessorModel(const std::string &physicalProcessorModel) {
+  physicalProcessorModel_ = physicalProcessorModel;
+  setParameter(std::string("PhysicalProcessorModel"), physicalProcessorModel);
+}
+
+float DescribeInstanceTypesRequest::getMaximumCpuTurboFrequency() const {
+  return maximumCpuTurboFrequency_;
+}
+
+void DescribeInstanceTypesRequest::setMaximumCpuTurboFrequency(float maximumCpuTurboFrequency) {
+  maximumCpuTurboFrequency_ = maximumCpuTurboFrequency;
+  setParameter(std::string("MaximumCpuTurboFrequency"), std::to_string(maximumCpuTurboFrequency));
+}
+
 std::vector<std::string> DescribeInstanceTypesRequest::getInstanceTypes() const {
   return instanceTypes_;
 }
@@ -42,6 +258,51 @@ void DescribeInstanceTypesRequest::setInstanceTypes(const std::vector<std::strin
   instanceTypes_ = instanceTypes;
 }
 
+long DescribeInstanceTypesRequest::getMinimumInstancePpsRx() const {
+  return minimumInstancePpsRx_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumInstancePpsRx(long minimumInstancePpsRx) {
+  minimumInstancePpsRx_ = minimumInstancePpsRx;
+  setParameter(std::string("MinimumInstancePpsRx"), std::to_string(minimumInstancePpsRx));
+}
+
+int DescribeInstanceTypesRequest::getMinimumEniIpv6AddressQuantity() const {
+  return minimumEniIpv6AddressQuantity_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumEniIpv6AddressQuantity(int minimumEniIpv6AddressQuantity) {
+  minimumEniIpv6AddressQuantity_ = minimumEniIpv6AddressQuantity;
+  setParameter(std::string("MinimumEniIpv6AddressQuantity"), std::to_string(minimumEniIpv6AddressQuantity));
+}
+
+int DescribeInstanceTypesRequest::getMinimumEriQuantity() const {
+  return minimumEriQuantity_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumEriQuantity(int minimumEriQuantity) {
+  minimumEriQuantity_ = minimumEriQuantity;
+  setParameter(std::string("MinimumEriQuantity"), std::to_string(minimumEriQuantity));
+}
+
+int DescribeInstanceTypesRequest::getMinimumDiskQuantity() const {
+  return minimumDiskQuantity_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumDiskQuantity(int minimumDiskQuantity) {
+  minimumDiskQuantity_ = minimumDiskQuantity;
+  setParameter(std::string("MinimumDiskQuantity"), std::to_string(minimumDiskQuantity));
+}
+
+float DescribeInstanceTypesRequest::getMinimumCpuTurboFrequency() const {
+  return minimumCpuTurboFrequency_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumCpuTurboFrequency(float minimumCpuTurboFrequency) {
+  minimumCpuTurboFrequency_ = minimumCpuTurboFrequency;
+  setParameter(std::string("MinimumCpuTurboFrequency"), std::to_string(minimumCpuTurboFrequency));
+}
+
 std::string DescribeInstanceTypesRequest::getNextToken() const {
   return nextToken_;
 }
@@ -51,6 +312,33 @@ void DescribeInstanceTypesRequest::setNextToken(const std::string &nextToken) {
   setParameter(std::string("NextToken"), nextToken);
 }
 
+int DescribeInstanceTypesRequest::getMinimumInstanceBandwidthRx() const {
+  return minimumInstanceBandwidthRx_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumInstanceBandwidthRx(int minimumInstanceBandwidthRx) {
+  minimumInstanceBandwidthRx_ = minimumInstanceBandwidthRx;
+  setParameter(std::string("MinimumInstanceBandwidthRx"), std::to_string(minimumInstanceBandwidthRx));
+}
+
+float DescribeInstanceTypesRequest::getMinimumCpuSpeedFrequency() const {
+  return minimumCpuSpeedFrequency_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumCpuSpeedFrequency(float minimumCpuSpeedFrequency) {
+  minimumCpuSpeedFrequency_ = minimumCpuSpeedFrequency;
+  setParameter(std::string("MinimumCpuSpeedFrequency"), std::to_string(minimumCpuSpeedFrequency));
+}
+
+std::string DescribeInstanceTypesRequest::getNvmeSupport() const {
+  return nvmeSupport_;
+}
+
+void DescribeInstanceTypesRequest::setNvmeSupport(const std::string &nvmeSupport) {
+  nvmeSupport_ = nvmeSupport;
+  setParameter(std::string("NvmeSupport"), nvmeSupport);
+}
+
 std::string DescribeInstanceTypesRequest::getResourceOwnerAccount() const {
   return resourceOwnerAccount_;
 }
@@ -69,6 +357,15 @@ void DescribeInstanceTypesRequest::setOwnerAccount(const std::string &ownerAccou
   setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
+int DescribeInstanceTypesRequest::getMinimumInitialCredit() const {
+  return minimumInitialCredit_;
+}
+
+void DescribeInstanceTypesRequest::setMinimumInitialCredit(int minimumInitialCredit) {
+  minimumInitialCredit_ = minimumInitialCredit;
+  setParameter(std::string("MinimumInitialCredit"), std::to_string(minimumInitialCredit));
+}
+
 std::string DescribeInstanceTypesRequest::getInstanceTypeFamily() const {
   return instanceTypeFamily_;
 }
@@ -78,21 +375,21 @@ void DescribeInstanceTypesRequest::setInstanceTypeFamily(const std::string &inst
   setParameter(std::string("InstanceTypeFamily"), instanceTypeFamily);
 }
 
-long DescribeInstanceTypesRequest::getOwnerId() const {
-  return ownerId_;
+int DescribeInstanceTypesRequest::getMinimumEniPrivateIpAddressQuantity() const {
+  return minimumEniPrivateIpAddressQuantity_;
 }
 
-void DescribeInstanceTypesRequest::setOwnerId(long ownerId) {
-  ownerId_ = ownerId;
-  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+void DescribeInstanceTypesRequest::setMinimumEniPrivateIpAddressQuantity(int minimumEniPrivateIpAddressQuantity) {
+  minimumEniPrivateIpAddressQuantity_ = minimumEniPrivateIpAddressQuantity;
+  setParameter(std::string("MinimumEniPrivateIpAddressQuantity"), std::to_string(minimumEniPrivateIpAddressQuantity));
 }
 
-long DescribeInstanceTypesRequest::getMaxResults() const {
-  return maxResults_;
+long DescribeInstanceTypesRequest::getMinimumLocalStorageCapacity() const {
+  return minimumLocalStorageCapacity_;
 }
 
-void DescribeInstanceTypesRequest::setMaxResults(long maxResults) {
-  maxResults_ = maxResults;
-  setParameter(std::string("MaxResults"), std::to_string(maxResults));
+void DescribeInstanceTypesRequest::setMinimumLocalStorageCapacity(long minimumLocalStorageCapacity) {
+  minimumLocalStorageCapacity_ = minimumLocalStorageCapacity;
+  setParameter(std::string("MinimumLocalStorageCapacity"), std::to_string(minimumLocalStorageCapacity));
 }
 

ecs/src/model/DescribeInstanceTypesResult.cc

@@ -101,6 +101,18 @@ void DescribeInstanceTypesResult::parse(const std::string &payload)
 			instanceTypesObject.eniQuantity = std::stoi(valueInstanceTypesInstanceType["EniQuantity"].asString());
 		if(!valueInstanceTypesInstanceType["EniTrunkSupported"].isNull())
 			instanceTypesObject.eniTrunkSupported = valueInstanceTypesInstanceType["EniTrunkSupported"].asString() == "true";
+		if(!valueInstanceTypesInstanceType["CpuSpeedFrequency"].isNull())
+			instanceTypesObject.cpuSpeedFrequency = std::stof(valueInstanceTypesInstanceType["CpuSpeedFrequency"].asString());
+		if(!valueInstanceTypesInstanceType["CpuTurboFrequency"].isNull())
+			instanceTypesObject.cpuTurboFrequency = std::stof(valueInstanceTypesInstanceType["CpuTurboFrequency"].asString());
+		if(!valueInstanceTypesInstanceType["PhysicalProcessorModel"].isNull())
+			instanceTypesObject.physicalProcessorModel = valueInstanceTypesInstanceType["PhysicalProcessorModel"].asString();
+		if(!valueInstanceTypesInstanceType["NetworkEncryptionSupport"].isNull())
+			instanceTypesObject.networkEncryptionSupport = valueInstanceTypesInstanceType["NetworkEncryptionSupport"].asString() == "true";
+		if(!valueInstanceTypesInstanceType["InstanceCategory"].isNull())
+			instanceTypesObject.instanceCategory = valueInstanceTypesInstanceType["InstanceCategory"].asString();
+		if(!valueInstanceTypesInstanceType["CpuArchitecture"].isNull())
+			instanceTypesObject.cpuArchitecture = valueInstanceTypesInstanceType["CpuArchitecture"].asString();
 		instanceTypes_.push_back(instanceTypesObject);
 	}
 	if(!value["NextToken"].isNull())