@aws-sdk/client-auto-scaling 3.36.1 → 3.40.0

package/dist-cjs/protocols/Aws_query.js

@@ -2264,6 +2264,14 @@ const deserializeAws_queryDescribeLoadBalancersCommandError = async (output, con
     let errorCode = "UnknownError";
     errorCode = loadQueryErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "InvalidNextToken":
+        case "com.amazonaws.autoscaling#InvalidNextToken":
+            response = {
+                ...(await deserializeAws_queryInvalidNextTokenResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         case "ResourceContentionFault":
         case "com.amazonaws.autoscaling#ResourceContentionFault":
             response = {
@@ -2311,6 +2319,14 @@ const deserializeAws_queryDescribeLoadBalancerTargetGroupsCommandError = async (
     let errorCode = "UnknownError";
     errorCode = loadQueryErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "InvalidNextToken":
+        case "com.amazonaws.autoscaling#InvalidNextToken":
+            response = {
+                ...(await deserializeAws_queryInvalidNextTokenResponse(parsedOutput, context)),
+                name: errorCode,
+                $metadata: deserializeMetadata(output),
+            };
+            break;
         case "ResourceContentionFault":
         case "com.amazonaws.autoscaling#ResourceContentionFault":
             response = {
@@ -4116,6 +4132,62 @@ const deserializeAws_queryServiceLinkedRoleFailureResponse = async (parsedOutput
     };
     return contents;
 };
+const serializeAws_queryAcceleratorCountRequest = (input, context) => {
+    const entries = {};
+    if (input.Min !== undefined && input.Min !== null) {
+        entries["Min"] = input.Min;
+    }
+    if (input.Max !== undefined && input.Max !== null) {
+        entries["Max"] = input.Max;
+    }
+    return entries;
+};
+const serializeAws_queryAcceleratorManufacturers = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`member.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
+const serializeAws_queryAcceleratorNames = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`member.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
+const serializeAws_queryAcceleratorTotalMemoryMiBRequest = (input, context) => {
+    const entries = {};
+    if (input.Min !== undefined && input.Min !== null) {
+        entries["Min"] = input.Min;
+    }
+    if (input.Max !== undefined && input.Max !== null) {
+        entries["Max"] = input.Max;
+    }
+    return entries;
+};
+const serializeAws_queryAcceleratorTypes = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`member.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
 const serializeAws_queryActivityIds = (input, context) => {
     const entries = {};
     let counter = 1;
@@ -4197,6 +4269,13 @@ const serializeAws_queryAutoScalingGroupNamesType = (input, context) => {
     if (input.MaxRecords !== undefined && input.MaxRecords !== null) {
         entries["MaxRecords"] = input.MaxRecords;
     }
+    if (input.Filters !== undefined && input.Filters !== null) {
+        const memberEntries = serializeAws_queryFilters(input.Filters, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Filters.${key}`;
+            entries[loc] = value;
+        });
+    }
     return entries;
 };
 const serializeAws_queryAutoScalingNotificationTypes = (input, context) => {
@@ -4223,6 +4302,16 @@ const serializeAws_queryAvailabilityZones = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryBaselineEbsBandwidthMbpsRequest = (input, context) => {
+    const entries = {};
+    if (input.Min !== undefined && input.Min !== null) {
+        entries["Min"] = input.Min;
+    }
+    if (input.Max !== undefined && input.Max !== null) {
+        entries["Max"] = input.Max;
+    }
+    return entries;
+};
 const serializeAws_queryBatchDeleteScheduledActionType = (input, context) => {
     const entries = {};
     if (input.AutoScalingGroupName !== undefined && input.AutoScalingGroupName !== null) {
@@ -4336,6 +4425,18 @@ const serializeAws_queryCompleteLifecycleActionType = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryCpuManufacturers = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`member.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
 const serializeAws_queryCreateAutoScalingGroupType = (input, context) => {
     const entries = {};
     if (input.AutoScalingGroupName !== undefined && input.AutoScalingGroupName !== null) {
@@ -4442,6 +4543,9 @@ const serializeAws_queryCreateAutoScalingGroupType = (input, context) => {
     if (input.Context !== undefined && input.Context !== null) {
         entries["Context"] = input.Context;
     }
+    if (input.DesiredCapacityType !== undefined && input.DesiredCapacityType !== null) {
+        entries["DesiredCapacityType"] = input.DesiredCapacityType;
+    }
     return entries;
 };
 const serializeAws_queryCreateLaunchConfigurationType = (input, context) => {
@@ -4966,6 +5070,18 @@ const serializeAws_queryEnterStandbyQuery = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryExcludedInstanceTypes = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`member.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
 const serializeAws_queryExecutePolicyType = (input, context) => {
     const entries = {};
     if (input.AutoScalingGroupName !== undefined && input.AutoScalingGroupName !== null) {
@@ -5044,6 +5160,18 @@ const serializeAws_queryGetPredictiveScalingForecastType = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryInstanceGenerations = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`member.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
 const serializeAws_queryInstanceIds = (input, context) => {
     const entries = {};
     let counter = 1;
@@ -5088,6 +5216,135 @@ const serializeAws_queryInstanceRefreshIds = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryInstanceRequirements = (input, context) => {
+    const entries = {};
+    if (input.VCpuCount !== undefined && input.VCpuCount !== null) {
+        const memberEntries = serializeAws_queryVCpuCountRequest(input.VCpuCount, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `VCpuCount.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.MemoryMiB !== undefined && input.MemoryMiB !== null) {
+        const memberEntries = serializeAws_queryMemoryMiBRequest(input.MemoryMiB, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `MemoryMiB.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.CpuManufacturers !== undefined && input.CpuManufacturers !== null) {
+        const memberEntries = serializeAws_queryCpuManufacturers(input.CpuManufacturers, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `CpuManufacturers.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.MemoryGiBPerVCpu !== undefined && input.MemoryGiBPerVCpu !== null) {
+        const memberEntries = serializeAws_queryMemoryGiBPerVCpuRequest(input.MemoryGiBPerVCpu, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `MemoryGiBPerVCpu.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.ExcludedInstanceTypes !== undefined && input.ExcludedInstanceTypes !== null) {
+        const memberEntries = serializeAws_queryExcludedInstanceTypes(input.ExcludedInstanceTypes, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `ExcludedInstanceTypes.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.InstanceGenerations !== undefined && input.InstanceGenerations !== null) {
+        const memberEntries = serializeAws_queryInstanceGenerations(input.InstanceGenerations, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `InstanceGenerations.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.SpotMaxPricePercentageOverLowestPrice !== undefined &&
+        input.SpotMaxPricePercentageOverLowestPrice !== null) {
+        entries["SpotMaxPricePercentageOverLowestPrice"] = input.SpotMaxPricePercentageOverLowestPrice;
+    }
+    if (input.OnDemandMaxPricePercentageOverLowestPrice !== undefined &&
+        input.OnDemandMaxPricePercentageOverLowestPrice !== null) {
+        entries["OnDemandMaxPricePercentageOverLowestPrice"] = input.OnDemandMaxPricePercentageOverLowestPrice;
+    }
+    if (input.BareMetal !== undefined && input.BareMetal !== null) {
+        entries["BareMetal"] = input.BareMetal;
+    }
+    if (input.BurstablePerformance !== undefined && input.BurstablePerformance !== null) {
+        entries["BurstablePerformance"] = input.BurstablePerformance;
+    }
+    if (input.RequireHibernateSupport !== undefined && input.RequireHibernateSupport !== null) {
+        entries["RequireHibernateSupport"] = input.RequireHibernateSupport;
+    }
+    if (input.NetworkInterfaceCount !== undefined && input.NetworkInterfaceCount !== null) {
+        const memberEntries = serializeAws_queryNetworkInterfaceCountRequest(input.NetworkInterfaceCount, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `NetworkInterfaceCount.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.LocalStorage !== undefined && input.LocalStorage !== null) {
+        entries["LocalStorage"] = input.LocalStorage;
+    }
+    if (input.LocalStorageTypes !== undefined && input.LocalStorageTypes !== null) {
+        const memberEntries = serializeAws_queryLocalStorageTypes(input.LocalStorageTypes, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `LocalStorageTypes.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.TotalLocalStorageGB !== undefined && input.TotalLocalStorageGB !== null) {
+        const memberEntries = serializeAws_queryTotalLocalStorageGBRequest(input.TotalLocalStorageGB, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TotalLocalStorageGB.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.BaselineEbsBandwidthMbps !== undefined && input.BaselineEbsBandwidthMbps !== null) {
+        const memberEntries = serializeAws_queryBaselineEbsBandwidthMbpsRequest(input.BaselineEbsBandwidthMbps, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `BaselineEbsBandwidthMbps.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.AcceleratorTypes !== undefined && input.AcceleratorTypes !== null) {
+        const memberEntries = serializeAws_queryAcceleratorTypes(input.AcceleratorTypes, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `AcceleratorTypes.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.AcceleratorCount !== undefined && input.AcceleratorCount !== null) {
+        const memberEntries = serializeAws_queryAcceleratorCountRequest(input.AcceleratorCount, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `AcceleratorCount.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.AcceleratorManufacturers !== undefined && input.AcceleratorManufacturers !== null) {
+        const memberEntries = serializeAws_queryAcceleratorManufacturers(input.AcceleratorManufacturers, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `AcceleratorManufacturers.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.AcceleratorNames !== undefined && input.AcceleratorNames !== null) {
+        const memberEntries = serializeAws_queryAcceleratorNames(input.AcceleratorNames, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `AcceleratorNames.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.AcceleratorTotalMemoryMiB !== undefined && input.AcceleratorTotalMemoryMiB !== null) {
+        const memberEntries = serializeAws_queryAcceleratorTotalMemoryMiBRequest(input.AcceleratorTotalMemoryMiB, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `AcceleratorTotalMemoryMiB.${key}`;
+            entries[loc] = value;
+        });
+    }
+    return entries;
+};
 const serializeAws_queryInstancesDistribution = (input, context) => {
     const entries = {};
     if (input.OnDemandAllocationStrategy !== undefined && input.OnDemandAllocationStrategy !== null) {
@@ -5179,6 +5436,13 @@ const serializeAws_queryLaunchTemplateOverrides = (input, context) => {
             entries[loc] = value;
         });
     }
+    if (input.InstanceRequirements !== undefined && input.InstanceRequirements !== null) {
+        const memberEntries = serializeAws_queryInstanceRequirements(input.InstanceRequirements, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `InstanceRequirements.${key}`;
+            entries[loc] = value;
+        });
+    }
     return entries;
 };
 const serializeAws_queryLaunchTemplateSpecification = (input, context) => {
@@ -5258,6 +5522,38 @@ const serializeAws_queryLoadBalancerNames = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryLocalStorageTypes = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`member.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
+const serializeAws_queryMemoryGiBPerVCpuRequest = (input, context) => {
+    const entries = {};
+    if (input.Min !== undefined && input.Min !== null) {
+        entries["Min"] = smithy_client_1.serializeFloat(input.Min);
+    }
+    if (input.Max !== undefined && input.Max !== null) {
+        entries["Max"] = smithy_client_1.serializeFloat(input.Max);
+    }
+    return entries;
+};
+const serializeAws_queryMemoryMiBRequest = (input, context) => {
+    const entries = {};
+    if (input.Min !== undefined && input.Min !== null) {
+        entries["Min"] = input.Min;
+    }
+    if (input.Max !== undefined && input.Max !== null) {
+        entries["Max"] = input.Max;
+    }
+    return entries;
+};
 const serializeAws_queryMetricDimension = (input, context) => {
     const entries = {};
     if (input.Name !== undefined && input.Name !== null) {
@@ -5313,6 +5609,16 @@ const serializeAws_queryMixedInstancesPolicy = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryNetworkInterfaceCountRequest = (input, context) => {
+    const entries = {};
+    if (input.Min !== undefined && input.Min !== null) {
+        entries["Min"] = input.Min;
+    }
+    if (input.Max !== undefined && input.Max !== null) {
+        entries["Max"] = input.Max;
+    }
+    return entries;
+};
 const serializeAws_queryOverrides = (input, context) => {
     const entries = {};
     let counter = 1;
@@ -5930,6 +6236,16 @@ const serializeAws_queryTerminationPolicies = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryTotalLocalStorageGBRequest = (input, context) => {
+    const entries = {};
+    if (input.Min !== undefined && input.Min !== null) {
+        entries["Min"] = smithy_client_1.serializeFloat(input.Min);
+    }
+    if (input.Max !== undefined && input.Max !== null) {
+        entries["Max"] = smithy_client_1.serializeFloat(input.Max);
+    }
+    return entries;
+};
 const serializeAws_queryUpdateAutoScalingGroupType = (input, context) => {
     const entries = {};
     if (input.AutoScalingGroupName !== undefined && input.AutoScalingGroupName !== null) {
@@ -6005,6 +6321,9 @@ const serializeAws_queryUpdateAutoScalingGroupType = (input, context) => {
     if (input.Context !== undefined && input.Context !== null) {
         entries["Context"] = input.Context;
     }
+    if (input.DesiredCapacityType !== undefined && input.DesiredCapacityType !== null) {
+        entries["DesiredCapacityType"] = input.DesiredCapacityType;
+    }
     return entries;
 };
 const serializeAws_queryValues = (input, context) => {
@@ -6019,6 +6338,72 @@ const serializeAws_queryValues = (input, context) => {
     }
     return entries;
 };
+const serializeAws_queryVCpuCountRequest = (input, context) => {
+    const entries = {};
+    if (input.Min !== undefined && input.Min !== null) {
+        entries["Min"] = input.Min;
+    }
+    if (input.Max !== undefined && input.Max !== null) {
+        entries["Max"] = input.Max;
+    }
+    return entries;
+};
+const deserializeAws_queryAcceleratorCountRequest = (output, context) => {
+    const contents = {
+        Min: undefined,
+        Max: undefined,
+    };
+    if (output["Min"] !== undefined) {
+        contents.Min = smithy_client_1.strictParseInt32(output["Min"]);
+    }
+    if (output["Max"] !== undefined) {
+        contents.Max = smithy_client_1.strictParseInt32(output["Max"]);
+    }
+    return contents;
+};
+const deserializeAws_queryAcceleratorManufacturers = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+const deserializeAws_queryAcceleratorNames = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+const deserializeAws_queryAcceleratorTotalMemoryMiBRequest = (output, context) => {
+    const contents = {
+        Min: undefined,
+        Max: undefined,
+    };
+    if (output["Min"] !== undefined) {
+        contents.Min = smithy_client_1.strictParseInt32(output["Min"]);
+    }
+    if (output["Max"] !== undefined) {
+        contents.Max = smithy_client_1.strictParseInt32(output["Max"]);
+    }
+    return contents;
+};
+const deserializeAws_queryAcceleratorTypes = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
 const deserializeAws_queryActiveInstanceRefreshNotFoundFault = (output, context) => {
     const contents = {
         message: undefined,
@@ -6208,6 +6593,7 @@ const deserializeAws_queryAutoScalingGroup = (output, context) => {
         WarmPoolConfiguration: undefined,
         WarmPoolSize: undefined,
         Context: undefined,
+        DesiredCapacityType: undefined,
     };
     if (output["AutoScalingGroupName"] !== undefined) {
         contents.AutoScalingGroupName = smithy_client_1.expectString(output["AutoScalingGroupName"]);
@@ -6326,6 +6712,9 @@ const deserializeAws_queryAutoScalingGroup = (output, context) => {
     if (output["Context"] !== undefined) {
         contents.Context = smithy_client_1.expectString(output["Context"]);
     }
+    if (output["DesiredCapacityType"] !== undefined) {
+        contents.DesiredCapacityType = smithy_client_1.expectString(output["DesiredCapacityType"]);
+    }
     return contents;
 };
 const deserializeAws_queryAutoScalingGroups = (output, context) => {
@@ -6445,6 +6834,19 @@ const deserializeAws_queryAvailabilityZones = (output, context) => {
         return smithy_client_1.expectString(entry);
     });
 };
+const deserializeAws_queryBaselineEbsBandwidthMbpsRequest = (output, context) => {
+    const contents = {
+        Min: undefined,
+        Max: undefined,
+    };
+    if (output["Min"] !== undefined) {
+        contents.Min = smithy_client_1.strictParseInt32(output["Min"]);
+    }
+    if (output["Max"] !== undefined) {
+        contents.Max = smithy_client_1.strictParseInt32(output["Max"]);
+    }
+    return contents;
+};
 const deserializeAws_queryBatchDeleteScheduledActionAnswer = (output, context) => {
     const contents = {
         FailedScheduledActions: undefined,
@@ -6553,6 +6955,16 @@ const deserializeAws_queryCompleteLifecycleActionAnswer = (output, context) => {
     const contents = {};
     return contents;
 };
+const deserializeAws_queryCpuManufacturers = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
 const deserializeAws_queryCustomizedMetricSpecification = (output, context) => {
     const contents = {
         MetricName: undefined,
@@ -6876,6 +7288,16 @@ const deserializeAws_queryEnterStandbyAnswer = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_queryExcludedInstanceTypes = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
 const deserializeAws_queryExitStandbyAnswer = (output, context) => {
     const contents = {
         Activities: undefined,
@@ -6976,6 +7398,16 @@ const deserializeAws_queryInstance = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_queryInstanceGenerations = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
 const deserializeAws_queryInstanceMetadataOptions = (output, context) => {
     const contents = {
         HttpTokens: undefined,
@@ -7109,6 +7541,116 @@ const deserializeAws_queryInstanceRefreshWarmPoolProgress = (output, context) =>
     }
     return contents;
 };
+const deserializeAws_queryInstanceRequirements = (output, context) => {
+    const contents = {
+        VCpuCount: undefined,
+        MemoryMiB: undefined,
+        CpuManufacturers: undefined,
+        MemoryGiBPerVCpu: undefined,
+        ExcludedInstanceTypes: undefined,
+        InstanceGenerations: undefined,
+        SpotMaxPricePercentageOverLowestPrice: undefined,
+        OnDemandMaxPricePercentageOverLowestPrice: undefined,
+        BareMetal: undefined,
+        BurstablePerformance: undefined,
+        RequireHibernateSupport: undefined,
+        NetworkInterfaceCount: undefined,
+        LocalStorage: undefined,
+        LocalStorageTypes: undefined,
+        TotalLocalStorageGB: undefined,
+        BaselineEbsBandwidthMbps: undefined,
+        AcceleratorTypes: undefined,
+        AcceleratorCount: undefined,
+        AcceleratorManufacturers: undefined,
+        AcceleratorNames: undefined,
+        AcceleratorTotalMemoryMiB: undefined,
+    };
+    if (output["VCpuCount"] !== undefined) {
+        contents.VCpuCount = deserializeAws_queryVCpuCountRequest(output["VCpuCount"], context);
+    }
+    if (output["MemoryMiB"] !== undefined) {
+        contents.MemoryMiB = deserializeAws_queryMemoryMiBRequest(output["MemoryMiB"], context);
+    }
+    if (output.CpuManufacturers === "") {
+        contents.CpuManufacturers = [];
+    }
+    if (output["CpuManufacturers"] !== undefined && output["CpuManufacturers"]["member"] !== undefined) {
+        contents.CpuManufacturers = deserializeAws_queryCpuManufacturers(smithy_client_1.getArrayIfSingleItem(output["CpuManufacturers"]["member"]), context);
+    }
+    if (output["MemoryGiBPerVCpu"] !== undefined) {
+        contents.MemoryGiBPerVCpu = deserializeAws_queryMemoryGiBPerVCpuRequest(output["MemoryGiBPerVCpu"], context);
+    }
+    if (output.ExcludedInstanceTypes === "") {
+        contents.ExcludedInstanceTypes = [];
+    }
+    if (output["ExcludedInstanceTypes"] !== undefined && output["ExcludedInstanceTypes"]["member"] !== undefined) {
+        contents.ExcludedInstanceTypes = deserializeAws_queryExcludedInstanceTypes(smithy_client_1.getArrayIfSingleItem(output["ExcludedInstanceTypes"]["member"]), context);
+    }
+    if (output.InstanceGenerations === "") {
+        contents.InstanceGenerations = [];
+    }
+    if (output["InstanceGenerations"] !== undefined && output["InstanceGenerations"]["member"] !== undefined) {
+        contents.InstanceGenerations = deserializeAws_queryInstanceGenerations(smithy_client_1.getArrayIfSingleItem(output["InstanceGenerations"]["member"]), context);
+    }
+    if (output["SpotMaxPricePercentageOverLowestPrice"] !== undefined) {
+        contents.SpotMaxPricePercentageOverLowestPrice = smithy_client_1.strictParseInt32(output["SpotMaxPricePercentageOverLowestPrice"]);
+    }
+    if (output["OnDemandMaxPricePercentageOverLowestPrice"] !== undefined) {
+        contents.OnDemandMaxPricePercentageOverLowestPrice = smithy_client_1.strictParseInt32(output["OnDemandMaxPricePercentageOverLowestPrice"]);
+    }
+    if (output["BareMetal"] !== undefined) {
+        contents.BareMetal = smithy_client_1.expectString(output["BareMetal"]);
+    }
+    if (output["BurstablePerformance"] !== undefined) {
+        contents.BurstablePerformance = smithy_client_1.expectString(output["BurstablePerformance"]);
+    }
+    if (output["RequireHibernateSupport"] !== undefined) {
+        contents.RequireHibernateSupport = smithy_client_1.parseBoolean(output["RequireHibernateSupport"]);
+    }
+    if (output["NetworkInterfaceCount"] !== undefined) {
+        contents.NetworkInterfaceCount = deserializeAws_queryNetworkInterfaceCountRequest(output["NetworkInterfaceCount"], context);
+    }
+    if (output["LocalStorage"] !== undefined) {
+        contents.LocalStorage = smithy_client_1.expectString(output["LocalStorage"]);
+    }
+    if (output.LocalStorageTypes === "") {
+        contents.LocalStorageTypes = [];
+    }
+    if (output["LocalStorageTypes"] !== undefined && output["LocalStorageTypes"]["member"] !== undefined) {
+        contents.LocalStorageTypes = deserializeAws_queryLocalStorageTypes(smithy_client_1.getArrayIfSingleItem(output["LocalStorageTypes"]["member"]), context);
+    }
+    if (output["TotalLocalStorageGB"] !== undefined) {
+        contents.TotalLocalStorageGB = deserializeAws_queryTotalLocalStorageGBRequest(output["TotalLocalStorageGB"], context);
+    }
+    if (output["BaselineEbsBandwidthMbps"] !== undefined) {
+        contents.BaselineEbsBandwidthMbps = deserializeAws_queryBaselineEbsBandwidthMbpsRequest(output["BaselineEbsBandwidthMbps"], context);
+    }
+    if (output.AcceleratorTypes === "") {
+        contents.AcceleratorTypes = [];
+    }
+    if (output["AcceleratorTypes"] !== undefined && output["AcceleratorTypes"]["member"] !== undefined) {
+        contents.AcceleratorTypes = deserializeAws_queryAcceleratorTypes(smithy_client_1.getArrayIfSingleItem(output["AcceleratorTypes"]["member"]), context);
+    }
+    if (output["AcceleratorCount"] !== undefined) {
+        contents.AcceleratorCount = deserializeAws_queryAcceleratorCountRequest(output["AcceleratorCount"], context);
+    }
+    if (output.AcceleratorManufacturers === "") {
+        contents.AcceleratorManufacturers = [];
+    }
+    if (output["AcceleratorManufacturers"] !== undefined && output["AcceleratorManufacturers"]["member"] !== undefined) {
+        contents.AcceleratorManufacturers = deserializeAws_queryAcceleratorManufacturers(smithy_client_1.getArrayIfSingleItem(output["AcceleratorManufacturers"]["member"]), context);
+    }
+    if (output.AcceleratorNames === "") {
+        contents.AcceleratorNames = [];
+    }
+    if (output["AcceleratorNames"] !== undefined && output["AcceleratorNames"]["member"] !== undefined) {
+        contents.AcceleratorNames = deserializeAws_queryAcceleratorNames(smithy_client_1.getArrayIfSingleItem(output["AcceleratorNames"]["member"]), context);
+    }
+    if (output["AcceleratorTotalMemoryMiB"] !== undefined) {
+        contents.AcceleratorTotalMemoryMiB = deserializeAws_queryAcceleratorTotalMemoryMiBRequest(output["AcceleratorTotalMemoryMiB"], context);
+    }
+    return contents;
+};
 const deserializeAws_queryInstances = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
@@ -7299,6 +7841,7 @@ const deserializeAws_queryLaunchTemplateOverrides = (output, context) => {
         InstanceType: undefined,
         WeightedCapacity: undefined,
         LaunchTemplateSpecification: undefined,
+        InstanceRequirements: undefined,
     };
     if (output["InstanceType"] !== undefined) {
         contents.InstanceType = smithy_client_1.expectString(output["InstanceType"]);
@@ -7309,6 +7852,9 @@ const deserializeAws_queryLaunchTemplateOverrides = (output, context) => {
     if (output["LaunchTemplateSpecification"] !== undefined) {
         contents.LaunchTemplateSpecification = deserializeAws_queryLaunchTemplateSpecification(output["LaunchTemplateSpecification"], context);
     }
+    if (output["InstanceRequirements"] !== undefined) {
+        contents.InstanceRequirements = deserializeAws_queryInstanceRequirements(output["InstanceRequirements"], context);
+    }
     return contents;
 };
 const deserializeAws_queryLaunchTemplateSpecification = (output, context) => {
@@ -7477,6 +8023,42 @@ const deserializeAws_queryLoadForecasts = (output, context) => {
         return deserializeAws_queryLoadForecast(entry, context);
     });
 };
+const deserializeAws_queryLocalStorageTypes = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return smithy_client_1.expectString(entry);
+    });
+};
+const deserializeAws_queryMemoryGiBPerVCpuRequest = (output, context) => {
+    const contents = {
+        Min: undefined,
+        Max: undefined,
+    };
+    if (output["Min"] !== undefined) {
+        contents.Min = smithy_client_1.strictParseFloat(output["Min"]);
+    }
+    if (output["Max"] !== undefined) {
+        contents.Max = smithy_client_1.strictParseFloat(output["Max"]);
+    }
+    return contents;
+};
+const deserializeAws_queryMemoryMiBRequest = (output, context) => {
+    const contents = {
+        Min: undefined,
+        Max: undefined,
+    };
+    if (output["Min"] !== undefined) {
+        contents.Min = smithy_client_1.strictParseInt32(output["Min"]);
+    }
+    if (output["Max"] !== undefined) {
+        contents.Max = smithy_client_1.strictParseInt32(output["Max"]);
+    }
+    return contents;
+};
 const deserializeAws_queryMetricCollectionType = (output, context) => {
     const contents = {
         Metric: undefined,
@@ -7551,6 +8133,19 @@ const deserializeAws_queryMixedInstancesPolicy = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_queryNetworkInterfaceCountRequest = (output, context) => {
+    const contents = {
+        Min: undefined,
+        Max: undefined,
+    };
+    if (output["Min"] !== undefined) {
+        contents.Min = smithy_client_1.strictParseInt32(output["Min"]);
+    }
+    if (output["Max"] !== undefined) {
+        contents.Max = smithy_client_1.strictParseInt32(output["Max"]);
+    }
+    return contents;
+};
 const deserializeAws_queryNotificationConfiguration = (output, context) => {
     const contents = {
         AutoScalingGroupName: undefined,
@@ -8184,6 +8779,32 @@ const deserializeAws_queryTerminationPolicies = (output, context) => {
         return smithy_client_1.expectString(entry);
     });
 };
+const deserializeAws_queryTotalLocalStorageGBRequest = (output, context) => {
+    const contents = {
+        Min: undefined,
+        Max: undefined,
+    };
+    if (output["Min"] !== undefined) {
+        contents.Min = smithy_client_1.strictParseFloat(output["Min"]);
+    }
+    if (output["Max"] !== undefined) {
+        contents.Max = smithy_client_1.strictParseFloat(output["Max"]);
+    }
+    return contents;
+};
+const deserializeAws_queryVCpuCountRequest = (output, context) => {
+    const contents = {
+        Min: undefined,
+        Max: undefined,
+    };
+    if (output["Min"] !== undefined) {
+        contents.Min = smithy_client_1.strictParseInt32(output["Min"]);
+    }
+    if (output["Max"] !== undefined) {
+        contents.Max = smithy_client_1.strictParseInt32(output["Max"]);
+    }
+    return contents;
+};
 const deserializeAws_queryWarmPoolConfiguration = (output, context) => {
     const contents = {
         MaxGroupPreparedCapacity: undefined,