@aws-sdk/client-ec2 3.218.0 → 3.219.0

package/dist-es/protocols/Aws_ec2.js

@@ -2487,6 +2487,18 @@ export const serializeAws_ec2DescribeAvailabilityZonesCommand = async (input, co
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2DescribeAwsNetworkPerformanceMetricSubscriptionsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DescribeAwsNetworkPerformanceMetricSubscriptionsRequest(input, context),
+        Action: "DescribeAwsNetworkPerformanceMetricSubscriptions",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2DescribeBundleTasksCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -4119,6 +4131,18 @@ export const serializeAws_ec2DisableAddressTransferCommand = async (input, conte
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2DisableAwsNetworkPerformanceMetricSubscriptionCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DisableAwsNetworkPerformanceMetricSubscriptionRequest(input, context),
+        Action: "DisableAwsNetworkPerformanceMetricSubscription",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2DisableEbsEncryptionByDefaultCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -4395,6 +4419,18 @@ export const serializeAws_ec2EnableAddressTransferCommand = async (input, contex
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2EnableAwsNetworkPerformanceMetricSubscriptionCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2EnableAwsNetworkPerformanceMetricSubscriptionRequest(input, context),
+        Action: "EnableAwsNetworkPerformanceMetricSubscription",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2EnableEbsEncryptionByDefaultCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -4455,6 +4491,18 @@ export const serializeAws_ec2EnableIpamOrganizationAdminAccountCommand = async (
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2EnableReachabilityAnalyzerOrganizationSharingCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2EnableReachabilityAnalyzerOrganizationSharingRequest(input, context),
+        Action: "EnableReachabilityAnalyzerOrganizationSharing",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2EnableSerialConsoleAccessCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -4599,6 +4647,18 @@ export const serializeAws_ec2GetAssociatedIpv6PoolCidrsCommand = async (input, c
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2GetAwsNetworkPerformanceDataCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2GetAwsNetworkPerformanceDataRequest(input, context),
+        Action: "GetAwsNetworkPerformanceData",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2GetCapacityReservationUsageCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -12072,6 +12132,33 @@ const deserializeAws_ec2DescribeAvailabilityZonesCommandError = async (output, c
         errorCode,
     });
 };
+export const deserializeAws_ec2DescribeAwsNetworkPerformanceMetricSubscriptionsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DescribeAwsNetworkPerformanceMetricSubscriptionsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DescribeAwsNetworkPerformanceMetricSubscriptionsResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DescribeAwsNetworkPerformanceMetricSubscriptionsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2DescribeBundleTasksCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2DescribeBundleTasksCommandError(output, context);
@@ -15735,6 +15822,33 @@ const deserializeAws_ec2DisableAddressTransferCommandError = async (output, cont
         errorCode,
     });
 };
+export const deserializeAws_ec2DisableAwsNetworkPerformanceMetricSubscriptionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DisableAwsNetworkPerformanceMetricSubscriptionCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DisableAwsNetworkPerformanceMetricSubscriptionResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DisableAwsNetworkPerformanceMetricSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2DisableEbsEncryptionByDefaultCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2DisableEbsEncryptionByDefaultCommandError(output, context);
@@ -16347,6 +16461,33 @@ const deserializeAws_ec2EnableAddressTransferCommandError = async (output, conte
         errorCode,
     });
 };
+export const deserializeAws_ec2EnableAwsNetworkPerformanceMetricSubscriptionCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2EnableAwsNetworkPerformanceMetricSubscriptionCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2EnableAwsNetworkPerformanceMetricSubscriptionResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2EnableAwsNetworkPerformanceMetricSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2EnableEbsEncryptionByDefaultCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2EnableEbsEncryptionByDefaultCommandError(output, context);
@@ -16482,6 +16623,33 @@ const deserializeAws_ec2EnableIpamOrganizationAdminAccountCommandError = async (
         errorCode,
     });
 };
+export const deserializeAws_ec2EnableReachabilityAnalyzerOrganizationSharingCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2EnableReachabilityAnalyzerOrganizationSharingCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2EnableReachabilityAnalyzerOrganizationSharingResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2EnableReachabilityAnalyzerOrganizationSharingCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2EnableSerialConsoleAccessCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2EnableSerialConsoleAccessCommandError(output, context);
@@ -16800,6 +16968,33 @@ const deserializeAws_ec2GetAssociatedIpv6PoolCidrsCommandError = async (output,
         errorCode,
     });
 };
+export const deserializeAws_ec2GetAwsNetworkPerformanceDataCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2GetAwsNetworkPerformanceDataCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2GetAwsNetworkPerformanceDataResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2GetAwsNetworkPerformanceDataCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadEc2ErrorCode(output, parsedOutput.body);
+    const parsedBody = parsedOutput.body;
+    throwDefaultError({
+        output,
+        parsedBody: parsedBody.Errors.Error,
+        exceptionCtor: __BaseException,
+        errorCode,
+    });
+};
 export const deserializeAws_ec2GetCapacityReservationUsageCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2GetCapacityReservationUsageCommandError(output, context);
@@ -22067,6 +22262,13 @@ const serializeAws_ec2AttachNetworkInterfaceRequest = (input, context) => {
     if (input.NetworkCardIndex != null) {
         entries["NetworkCardIndex"] = input.NetworkCardIndex;
     }
+    if (input.EnaSrdSpecification != null) {
+        const memberEntries = serializeAws_ec2EnaSrdSpecification(input.EnaSrdSpecification, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `EnaSrdSpecification.${key}`;
+            entries[loc] = value;
+        });
+    }
     return entries;
 };
 const serializeAws_ec2AttachVolumeRequest = (input, context) => {
@@ -25591,6 +25793,43 @@ const serializeAws_ec2CustomerGatewayIdStringList = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2DataQueries = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        const memberEntries = serializeAws_ec2DataQuery(entry, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            entries[`Member.${counter}.${key}`] = value;
+        });
+        counter++;
+    }
+    return entries;
+};
+const serializeAws_ec2DataQuery = (input, context) => {
+    const entries = {};
+    if (input.Id != null) {
+        entries["Id"] = input.Id;
+    }
+    if (input.Source != null) {
+        entries["Source"] = input.Source;
+    }
+    if (input.Destination != null) {
+        entries["Destination"] = input.Destination;
+    }
+    if (input.Metric != null) {
+        entries["Metric"] = input.Metric;
+    }
+    if (input.Statistic != null) {
+        entries["Statistic"] = input.Statistic;
+    }
+    if (input.Period != null) {
+        entries["Period"] = input.Period;
+    }
+    return entries;
+};
 const serializeAws_ec2DedicatedHostIdList = (input, context) => {
     const entries = {};
     let counter = 1;
@@ -26692,6 +26931,29 @@ const serializeAws_ec2DescribeAvailabilityZonesRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2DescribeAwsNetworkPerformanceMetricSubscriptionsRequest = (input, context) => {
+    const entries = {};
+    if (input.MaxResults != null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    if (input.NextToken != null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.Filters != null) {
+        const memberEntries = serializeAws_ec2FilterList(input.Filters, context);
+        if (input.Filters?.length === 0) {
+            entries.Filter = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `Filter.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 const serializeAws_ec2DescribeBundleTasksRequest = (input, context) => {
     const entries = {};
     if (input.BundleIds != null) {
@@ -30724,6 +30986,25 @@ const serializeAws_ec2DisableAddressTransferRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2DisableAwsNetworkPerformanceMetricSubscriptionRequest = (input, context) => {
+    const entries = {};
+    if (input.Source != null) {
+        entries["Source"] = input.Source;
+    }
+    if (input.Destination != null) {
+        entries["Destination"] = input.Destination;
+    }
+    if (input.Metric != null) {
+        entries["Metric"] = input.Metric;
+    }
+    if (input.Statistic != null) {
+        entries["Statistic"] = input.Statistic;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 const serializeAws_ec2DisableEbsEncryptionByDefaultRequest = (input, context) => {
     const entries = {};
     if (input.DryRun != null) {
@@ -31209,6 +31490,25 @@ const serializeAws_ec2EnableAddressTransferRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2EnableAwsNetworkPerformanceMetricSubscriptionRequest = (input, context) => {
+    const entries = {};
+    if (input.Source != null) {
+        entries["Source"] = input.Source;
+    }
+    if (input.Destination != null) {
+        entries["Destination"] = input.Destination;
+    }
+    if (input.Metric != null) {
+        entries["Metric"] = input.Metric;
+    }
+    if (input.Statistic != null) {
+        entries["Statistic"] = input.Statistic;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 const serializeAws_ec2EnableEbsEncryptionByDefaultRequest = (input, context) => {
     const entries = {};
     if (input.DryRun != null) {
@@ -31296,6 +31596,13 @@ const serializeAws_ec2EnableIpamOrganizationAdminAccountRequest = (input, contex
     }
     return entries;
 };
+const serializeAws_ec2EnableReachabilityAnalyzerOrganizationSharingRequest = (input, context) => {
+    const entries = {};
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 const serializeAws_ec2EnableSerialConsoleAccessRequest = (input, context) => {
     const entries = {};
     if (input.DryRun != null) {
@@ -31359,6 +31666,27 @@ const serializeAws_ec2EnableVpcClassicLinkRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2EnaSrdSpecification = (input, context) => {
+    const entries = {};
+    if (input.EnaSrdEnabled != null) {
+        entries["EnaSrdEnabled"] = input.EnaSrdEnabled;
+    }
+    if (input.EnaSrdUdpSpecification != null) {
+        const memberEntries = serializeAws_ec2EnaSrdUdpSpecification(input.EnaSrdUdpSpecification, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `EnaSrdUdpSpecification.${key}`;
+            entries[loc] = value;
+        });
+    }
+    return entries;
+};
+const serializeAws_ec2EnaSrdUdpSpecification = (input, context) => {
+    const entries = {};
+    if (input.EnaSrdUdpEnabled != null) {
+        entries["EnaSrdUdpEnabled"] = input.EnaSrdUdpEnabled;
+    }
+    return entries;
+};
 const serializeAws_ec2EnclaveOptionsRequest = (input, context) => {
     const entries = {};
     if (input.Enabled != null) {
@@ -31810,6 +32138,35 @@ const serializeAws_ec2GetAssociatedIpv6PoolCidrsRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2GetAwsNetworkPerformanceDataRequest = (input, context) => {
+    const entries = {};
+    if (input.DataQueries != null) {
+        const memberEntries = serializeAws_ec2DataQueries(input.DataQueries, context);
+        if (input.DataQueries?.length === 0) {
+            entries.DataQuery = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `DataQuery.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.StartTime != null) {
+        entries["StartTime"] = input.StartTime.toISOString().split(".")[0] + "Z";
+    }
+    if (input.EndTime != null) {
+        entries["EndTime"] = input.EndTime.toISOString().split(".")[0] + "Z";
+    }
+    if (input.MaxResults != null) {
+        entries["MaxResults"] = input.MaxResults;
+    }
+    if (input.NextToken != null) {
+        entries["NextToken"] = input.NextToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 const serializeAws_ec2GetCapacityReservationUsageRequest = (input, context) => {
     const entries = {};
     if (input.CapacityReservationId != null) {
@@ -35879,6 +36236,13 @@ const serializeAws_ec2ModifyNetworkInterfaceAttributeRequest = (input, context)
             entries[loc] = value;
         });
     }
+    if (input.EnaSrdSpecification != null) {
+        const memberEntries = serializeAws_ec2EnaSrdSpecification(input.EnaSrdSpecification, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `EnaSrdSpecification.${key}`;
+            entries[loc] = value;
+        });
+    }
     return entries;
 };
 const serializeAws_ec2ModifyPrivateDnsNameOptionsRequest = (input, context) => {
@@ -40650,6 +41014,16 @@ const serializeAws_ec2StartNetworkInsightsAnalysisRequest = (input, context) =>
     if (input.NetworkInsightsPathId != null) {
         entries["NetworkInsightsPathId"] = input.NetworkInsightsPathId;
     }
+    if (input.AdditionalAccounts != null) {
+        const memberEntries = serializeAws_ec2ValueStringList(input.AdditionalAccounts, context);
+        if (input.AdditionalAccounts?.length === 0) {
+            entries.AdditionalAccount = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `AdditionalAccount.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
     if (input.FilterInArns != null) {
         const memberEntries = serializeAws_ec2ArnList(input.FilterInArns, context);
         if (input.FilterInArns?.length === 0) {
@@ -42899,6 +43273,28 @@ const deserializeAws_ec2AttachClassicLinkVpcResult = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2AttachmentEnaSrdSpecification = (output, context) => {
+    const contents = {
+        EnaSrdEnabled: undefined,
+        EnaSrdUdpSpecification: undefined,
+    };
+    if (output["enaSrdEnabled"] !== undefined) {
+        contents.EnaSrdEnabled = __parseBoolean(output["enaSrdEnabled"]);
+    }
+    if (output["enaSrdUdpSpecification"] !== undefined) {
+        contents.EnaSrdUdpSpecification = deserializeAws_ec2AttachmentEnaSrdUdpSpecification(output["enaSrdUdpSpecification"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2AttachmentEnaSrdUdpSpecification = (output, context) => {
+    const contents = {
+        EnaSrdUdpEnabled: undefined,
+    };
+    if (output["enaSrdUdpEnabled"] !== undefined) {
+        contents.EnaSrdUdpEnabled = __parseBoolean(output["enaSrdUdpEnabled"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2AttachNetworkInterfaceResult = (output, context) => {
     const contents = {
         AttachmentId: undefined,
@@ -45437,6 +45833,49 @@ const deserializeAws_ec2CustomerGatewayList = (output, context) => {
         return deserializeAws_ec2CustomerGateway(entry, context);
     });
 };
+const deserializeAws_ec2DataResponse = (output, context) => {
+    const contents = {
+        Id: undefined,
+        Source: undefined,
+        Destination: undefined,
+        Metric: undefined,
+        Statistic: undefined,
+        Period: undefined,
+        MetricPoints: undefined,
+    };
+    if (output["id"] !== undefined) {
+        contents.Id = __expectString(output["id"]);
+    }
+    if (output["source"] !== undefined) {
+        contents.Source = __expectString(output["source"]);
+    }
+    if (output["destination"] !== undefined) {
+        contents.Destination = __expectString(output["destination"]);
+    }
+    if (output["metric"] !== undefined) {
+        contents.Metric = __expectString(output["metric"]);
+    }
+    if (output["statistic"] !== undefined) {
+        contents.Statistic = __expectString(output["statistic"]);
+    }
+    if (output["period"] !== undefined) {
+        contents.Period = __expectString(output["period"]);
+    }
+    if (output.metricPointSet === "") {
+        contents.MetricPoints = [];
+    }
+    else if (output["metricPointSet"] !== undefined && output["metricPointSet"]["item"] !== undefined) {
+        contents.MetricPoints = deserializeAws_ec2MetricPoints(__getArrayIfSingleItem(output["metricPointSet"]["item"]), context);
+    }
+    return contents;
+};
+const deserializeAws_ec2DataResponses = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2DataResponse(entry, context);
+    });
+};
 const deserializeAws_ec2DedicatedHostIdList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
@@ -46202,6 +46641,22 @@ const deserializeAws_ec2DescribeAvailabilityZonesResult = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2DescribeAwsNetworkPerformanceMetricSubscriptionsResult = (output, context) => {
+    const contents = {
+        NextToken: undefined,
+        Subscriptions: undefined,
+    };
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    if (output.subscriptionSet === "") {
+        contents.Subscriptions = [];
+    }
+    else if (output["subscriptionSet"] !== undefined && output["subscriptionSet"]["item"] !== undefined) {
+        contents.Subscriptions = deserializeAws_ec2SubscriptionList(__getArrayIfSingleItem(output["subscriptionSet"]["item"]), context);
+    }
+    return contents;
+};
 const deserializeAws_ec2DescribeBundleTasksResult = (output, context) => {
     const contents = {
         BundleTasks: undefined,
@@ -48558,6 +49013,15 @@ const deserializeAws_ec2DisableAddressTransferResult = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2DisableAwsNetworkPerformanceMetricSubscriptionResult = (output, context) => {
+    const contents = {
+        Output: undefined,
+    };
+    if (output["output"] !== undefined) {
+        contents.Output = __parseBoolean(output["output"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2DisableEbsEncryptionByDefaultResult = (output, context) => {
     const contents = {
         EbsEncryptionByDefault: undefined,
@@ -49275,6 +49739,15 @@ const deserializeAws_ec2EnableAddressTransferResult = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2EnableAwsNetworkPerformanceMetricSubscriptionResult = (output, context) => {
+    const contents = {
+        Output: undefined,
+    };
+    if (output["output"] !== undefined) {
+        contents.Output = __parseBoolean(output["output"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2EnableEbsEncryptionByDefaultResult = (output, context) => {
     const contents = {
         EbsEncryptionByDefault: undefined,
@@ -49475,6 +49948,15 @@ const deserializeAws_ec2EnableIpamOrganizationAdminAccountResult = (output, cont
     }
     return contents;
 };
+const deserializeAws_ec2EnableReachabilityAnalyzerOrganizationSharingResult = (output, context) => {
+    const contents = {
+        ReturnValue: undefined,
+    };
+    if (output["returnValue"] !== undefined) {
+        contents.ReturnValue = __parseBoolean(output["returnValue"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2EnableSerialConsoleAccessResult = (output, context) => {
     const contents = {
         SerialConsoleAccessEnabled: undefined,
@@ -50634,6 +51116,22 @@ const deserializeAws_ec2GetAssociatedIpv6PoolCidrsResult = (output, context) =>
     }
     return contents;
 };
+const deserializeAws_ec2GetAwsNetworkPerformanceDataResult = (output, context) => {
+    const contents = {
+        DataResponses: undefined,
+        NextToken: undefined,
+    };
+    if (output.dataResponseSet === "") {
+        contents.DataResponses = [];
+    }
+    else if (output["dataResponseSet"] !== undefined && output["dataResponseSet"]["item"] !== undefined) {
+        contents.DataResponses = deserializeAws_ec2DataResponses(__getArrayIfSingleItem(output["dataResponseSet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2GetCapacityReservationUsageResult = (output, context) => {
     const contents = {
         NextToken: undefined,
@@ -55976,6 +56474,34 @@ const deserializeAws_ec2MemoryMiB = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2MetricPoint = (output, context) => {
+    const contents = {
+        StartDate: undefined,
+        EndDate: undefined,
+        Value: undefined,
+        Status: undefined,
+    };
+    if (output["startDate"] !== undefined) {
+        contents.StartDate = __expectNonNull(__parseRfc3339DateTime(output["startDate"]));
+    }
+    if (output["endDate"] !== undefined) {
+        contents.EndDate = __expectNonNull(__parseRfc3339DateTime(output["endDate"]));
+    }
+    if (output["value"] !== undefined) {
+        contents.Value = __strictParseFloat(output["value"]);
+    }
+    if (output["status"] !== undefined) {
+        contents.Status = __expectString(output["status"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2MetricPoints = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2MetricPoint(entry, context);
+    });
+};
 const deserializeAws_ec2ModifyAddressAttributeResult = (output, context) => {
     const contents = {
         Address: undefined,
@@ -56769,6 +57295,7 @@ const deserializeAws_ec2NetworkInfo = (output, context) => {
         EfaSupported: undefined,
         EfaInfo: undefined,
         EncryptionInTransitSupported: undefined,
+        EnaSrdSupported: undefined,
     };
     if (output["networkPerformance"] !== undefined) {
         contents.NetworkPerformance = __expectString(output["networkPerformance"]);
@@ -56809,6 +57336,9 @@ const deserializeAws_ec2NetworkInfo = (output, context) => {
     if (output["encryptionInTransitSupported"] !== undefined) {
         contents.EncryptionInTransitSupported = __parseBoolean(output["encryptionInTransitSupported"]);
     }
+    if (output["enaSrdSupported"] !== undefined) {
+        contents.EnaSrdSupported = __parseBoolean(output["enaSrdSupported"]);
+    }
     return contents;
 };
 const deserializeAws_ec2NetworkInsightsAccessScope = (output, context) => {
@@ -56933,6 +57463,7 @@ const deserializeAws_ec2NetworkInsightsAnalysis = (output, context) => {
         NetworkInsightsAnalysisId: undefined,
         NetworkInsightsAnalysisArn: undefined,
         NetworkInsightsPathId: undefined,
+        AdditionalAccounts: undefined,
         FilterInArns: undefined,
         StartDate: undefined,
         Status: undefined,
@@ -56943,6 +57474,7 @@ const deserializeAws_ec2NetworkInsightsAnalysis = (output, context) => {
         ReturnPathComponents: undefined,
         Explanations: undefined,
         AlternatePathHints: undefined,
+        SuggestedAccounts: undefined,
         Tags: undefined,
     };
     if (output["networkInsightsAnalysisId"] !== undefined) {
@@ -56954,6 +57486,12 @@ const deserializeAws_ec2NetworkInsightsAnalysis = (output, context) => {
     if (output["networkInsightsPathId"] !== undefined) {
         contents.NetworkInsightsPathId = __expectString(output["networkInsightsPathId"]);
     }
+    if (output.additionalAccountSet === "") {
+        contents.AdditionalAccounts = [];
+    }
+    else if (output["additionalAccountSet"] !== undefined && output["additionalAccountSet"]["item"] !== undefined) {
+        contents.AdditionalAccounts = deserializeAws_ec2ValueStringList(__getArrayIfSingleItem(output["additionalAccountSet"]["item"]), context);
+    }
     if (output.filterInArnSet === "") {
         contents.FilterInArns = [];
     }
@@ -57000,6 +57538,12 @@ const deserializeAws_ec2NetworkInsightsAnalysis = (output, context) => {
     else if (output["alternatePathHintSet"] !== undefined && output["alternatePathHintSet"]["item"] !== undefined) {
         contents.AlternatePathHints = deserializeAws_ec2AlternatePathHintList(__getArrayIfSingleItem(output["alternatePathHintSet"]["item"]), context);
     }
+    if (output.suggestedAccountSet === "") {
+        contents.SuggestedAccounts = [];
+    }
+    else if (output["suggestedAccountSet"] !== undefined && output["suggestedAccountSet"]["item"] !== undefined) {
+        contents.SuggestedAccounts = deserializeAws_ec2ValueStringList(__getArrayIfSingleItem(output["suggestedAccountSet"]["item"]), context);
+    }
     if (output.tagSet === "") {
         contents.Tags = [];
     }
@@ -57022,6 +57566,8 @@ const deserializeAws_ec2NetworkInsightsPath = (output, context) => {
         CreatedDate: undefined,
         Source: undefined,
         Destination: undefined,
+        SourceArn: undefined,
+        DestinationArn: undefined,
         SourceIp: undefined,
         DestinationIp: undefined,
         Protocol: undefined,
@@ -57043,6 +57589,12 @@ const deserializeAws_ec2NetworkInsightsPath = (output, context) => {
     if (output["destination"] !== undefined) {
         contents.Destination = __expectString(output["destination"]);
     }
+    if (output["sourceArn"] !== undefined) {
+        contents.SourceArn = __expectString(output["sourceArn"]);
+    }
+    if (output["destinationArn"] !== undefined) {
+        contents.DestinationArn = __expectString(output["destinationArn"]);
+    }
     if (output["sourceIp"] !== undefined) {
         contents.SourceIp = __expectString(output["sourceIp"]);
     }
@@ -57240,6 +57792,7 @@ const deserializeAws_ec2NetworkInterfaceAttachment = (output, context) => {
         InstanceId: undefined,
         InstanceOwnerId: undefined,
         Status: undefined,
+        EnaSrdSpecification: undefined,
     };
     if (output["attachTime"] !== undefined) {
         contents.AttachTime = __expectNonNull(__parseRfc3339DateTime(output["attachTime"]));
@@ -57265,6 +57818,9 @@ const deserializeAws_ec2NetworkInterfaceAttachment = (output, context) => {
     if (output["status"] !== undefined) {
         contents.Status = __expectString(output["status"]);
     }
+    if (output["enaSrdSpecification"] !== undefined) {
+        contents.EnaSrdSpecification = deserializeAws_ec2AttachmentEnaSrdSpecification(output["enaSrdSpecification"], context);
+    }
     return contents;
 };
 const deserializeAws_ec2NetworkInterfaceCount = (output, context) => {
@@ -61652,6 +62208,38 @@ const deserializeAws_ec2SubnetList = (output, context) => {
         return deserializeAws_ec2Subnet(entry, context);
     });
 };
+const deserializeAws_ec2Subscription = (output, context) => {
+    const contents = {
+        Source: undefined,
+        Destination: undefined,
+        Metric: undefined,
+        Statistic: undefined,
+        Period: undefined,
+    };
+    if (output["source"] !== undefined) {
+        contents.Source = __expectString(output["source"]);
+    }
+    if (output["destination"] !== undefined) {
+        contents.Destination = __expectString(output["destination"]);
+    }
+    if (output["metric"] !== undefined) {
+        contents.Metric = __expectString(output["metric"]);
+    }
+    if (output["statistic"] !== undefined) {
+        contents.Statistic = __expectString(output["statistic"]);
+    }
+    if (output["period"] !== undefined) {
+        contents.Period = __expectString(output["period"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2SubscriptionList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2Subscription(entry, context);
+    });
+};
 const deserializeAws_ec2SuccessfulInstanceCreditSpecificationItem = (output, context) => {
     const contents = {
         InstanceId: undefined,