@aws-sdk/client-ec2 3.218.0 → 3.220.0

package/dist-es/protocols/Aws_ec2.js

@@ -363,6 +363,18 @@ export const serializeAws_ec2AttachNetworkInterfaceCommand = async (input, conte
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2AttachVerifiedAccessTrustProviderCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2AttachVerifiedAccessTrustProviderRequest(input, context),
+        Action: "AttachVerifiedAccessTrustProvider",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2AttachVolumeCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -1407,6 +1419,54 @@ export const serializeAws_ec2CreateTransitGatewayVpcAttachmentCommand = async (i
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2CreateVerifiedAccessEndpointCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2CreateVerifiedAccessEndpointRequest(input, context),
+        Action: "CreateVerifiedAccessEndpoint",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2CreateVerifiedAccessGroupCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2CreateVerifiedAccessGroupRequest(input, context),
+        Action: "CreateVerifiedAccessGroup",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2CreateVerifiedAccessInstanceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2CreateVerifiedAccessInstanceRequest(input, context),
+        Action: "CreateVerifiedAccessInstance",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2CreateVerifiedAccessTrustProviderCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2CreateVerifiedAccessTrustProviderRequest(input, context),
+        Action: "CreateVerifiedAccessTrustProvider",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2CreateVolumeCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -2223,6 +2283,54 @@ export const serializeAws_ec2DeleteTransitGatewayVpcAttachmentCommand = async (i
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2DeleteVerifiedAccessEndpointCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DeleteVerifiedAccessEndpointRequest(input, context),
+        Action: "DeleteVerifiedAccessEndpoint",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2DeleteVerifiedAccessGroupCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DeleteVerifiedAccessGroupRequest(input, context),
+        Action: "DeleteVerifiedAccessGroup",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2DeleteVerifiedAccessInstanceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DeleteVerifiedAccessInstanceRequest(input, context),
+        Action: "DeleteVerifiedAccessInstance",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2DeleteVerifiedAccessTrustProviderCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DeleteVerifiedAccessTrustProviderRequest(input, context),
+        Action: "DeleteVerifiedAccessTrustProvider",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2DeleteVolumeCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -2487,6 +2595,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",
@@ -3843,6 +3963,66 @@ export const serializeAws_ec2DescribeTrunkInterfaceAssociationsCommand = async (
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2DescribeVerifiedAccessEndpointsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DescribeVerifiedAccessEndpointsRequest(input, context),
+        Action: "DescribeVerifiedAccessEndpoints",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2DescribeVerifiedAccessGroupsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DescribeVerifiedAccessGroupsRequest(input, context),
+        Action: "DescribeVerifiedAccessGroups",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2DescribeVerifiedAccessInstanceLoggingConfigurationsCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DescribeVerifiedAccessInstanceLoggingConfigurationsRequest(input, context),
+        Action: "DescribeVerifiedAccessInstanceLoggingConfigurations",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2DescribeVerifiedAccessInstancesCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DescribeVerifiedAccessInstancesRequest(input, context),
+        Action: "DescribeVerifiedAccessInstances",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2DescribeVerifiedAccessTrustProvidersCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DescribeVerifiedAccessTrustProvidersRequest(input, context),
+        Action: "DescribeVerifiedAccessTrustProviders",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2DescribeVolumeAttributeCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -4083,6 +4263,18 @@ export const serializeAws_ec2DetachNetworkInterfaceCommand = async (input, conte
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2DetachVerifiedAccessTrustProviderCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2DetachVerifiedAccessTrustProviderRequest(input, context),
+        Action: "DetachVerifiedAccessTrustProvider",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2DetachVolumeCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -4119,6 +4311,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 +4599,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 +4671,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 +4827,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",
@@ -4995,6 +5235,30 @@ export const serializeAws_ec2GetTransitGatewayRouteTablePropagationsCommand = as
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2GetVerifiedAccessEndpointPolicyCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2GetVerifiedAccessEndpointPolicyRequest(input, context),
+        Action: "GetVerifiedAccessEndpointPolicy",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2GetVerifiedAccessGroupPolicyCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2GetVerifiedAccessGroupPolicyRequest(input, context),
+        Action: "GetVerifiedAccessGroupPolicy",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2GetVpnConnectionDeviceSampleConfigurationCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -5619,6 +5883,90 @@ export const serializeAws_ec2ModifyTransitGatewayVpcAttachmentCommand = async (i
     });
     return buildHttpRpcRequest(context, headers, "/", undefined, body);
 };
+export const serializeAws_ec2ModifyVerifiedAccessEndpointCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2ModifyVerifiedAccessEndpointRequest(input, context),
+        Action: "ModifyVerifiedAccessEndpoint",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2ModifyVerifiedAccessEndpointPolicyCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2ModifyVerifiedAccessEndpointPolicyRequest(input, context),
+        Action: "ModifyVerifiedAccessEndpointPolicy",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2ModifyVerifiedAccessGroupCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2ModifyVerifiedAccessGroupRequest(input, context),
+        Action: "ModifyVerifiedAccessGroup",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2ModifyVerifiedAccessGroupPolicyCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2ModifyVerifiedAccessGroupPolicyRequest(input, context),
+        Action: "ModifyVerifiedAccessGroupPolicy",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2ModifyVerifiedAccessInstanceCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2ModifyVerifiedAccessInstanceRequest(input, context),
+        Action: "ModifyVerifiedAccessInstance",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2ModifyVerifiedAccessInstanceLoggingConfigurationCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2ModifyVerifiedAccessInstanceLoggingConfigurationRequest(input, context),
+        Action: "ModifyVerifiedAccessInstanceLoggingConfiguration",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+export const serializeAws_ec2ModifyVerifiedAccessTrustProviderCommand = async (input, context) => {
+    const headers = {
+        "content-type": "application/x-www-form-urlencoded",
+    };
+    let body;
+    body = buildFormUrlencodedString({
+        ...serializeAws_ec2ModifyVerifiedAccessTrustProviderRequest(input, context),
+        Action: "ModifyVerifiedAccessTrustProvider",
+        Version: "2016-11-15",
+    });
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
 export const serializeAws_ec2ModifyVolumeCommand = async (input, context) => {
     const headers = {
         "content-type": "application/x-www-form-urlencoded",
@@ -7371,6 +7719,33 @@ const deserializeAws_ec2AttachNetworkInterfaceCommandError = async (output, cont
         errorCode,
     });
 };
+export const deserializeAws_ec2AttachVerifiedAccessTrustProviderCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2AttachVerifiedAccessTrustProviderCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2AttachVerifiedAccessTrustProviderResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2AttachVerifiedAccessTrustProviderCommandError = 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_ec2AttachVolumeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2AttachVolumeCommandError(output, context);
@@ -9708,6 +10083,114 @@ const deserializeAws_ec2CreateTransitGatewayVpcAttachmentCommandError = async (o
         errorCode,
     });
 };
+export const deserializeAws_ec2CreateVerifiedAccessEndpointCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2CreateVerifiedAccessEndpointCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2CreateVerifiedAccessEndpointResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2CreateVerifiedAccessEndpointCommandError = 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_ec2CreateVerifiedAccessGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2CreateVerifiedAccessGroupCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2CreateVerifiedAccessGroupResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2CreateVerifiedAccessGroupCommandError = 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_ec2CreateVerifiedAccessInstanceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2CreateVerifiedAccessInstanceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2CreateVerifiedAccessInstanceResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2CreateVerifiedAccessInstanceCommandError = 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_ec2CreateVerifiedAccessTrustProviderCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2CreateVerifiedAccessTrustProviderCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2CreateVerifiedAccessTrustProviderResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2CreateVerifiedAccessTrustProviderCommandError = 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_ec2CreateVolumeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2CreateVolumeCommandError(output, context);
@@ -11496,6 +11979,114 @@ const deserializeAws_ec2DeleteTransitGatewayVpcAttachmentCommandError = async (o
         errorCode,
     });
 };
+export const deserializeAws_ec2DeleteVerifiedAccessEndpointCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DeleteVerifiedAccessEndpointCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DeleteVerifiedAccessEndpointResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DeleteVerifiedAccessEndpointCommandError = 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_ec2DeleteVerifiedAccessGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DeleteVerifiedAccessGroupCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DeleteVerifiedAccessGroupResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DeleteVerifiedAccessGroupCommandError = 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_ec2DeleteVerifiedAccessInstanceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DeleteVerifiedAccessInstanceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DeleteVerifiedAccessInstanceResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DeleteVerifiedAccessInstanceCommandError = 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_ec2DeleteVerifiedAccessTrustProviderCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DeleteVerifiedAccessTrustProviderCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DeleteVerifiedAccessTrustProviderResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DeleteVerifiedAccessTrustProviderCommandError = 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_ec2DeleteVolumeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2DeleteVolumeCommandError(output, context);
@@ -12072,6 +12663,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);
@@ -15123,6 +15741,141 @@ const deserializeAws_ec2DescribeTrunkInterfaceAssociationsCommandError = async (
         errorCode,
     });
 };
+export const deserializeAws_ec2DescribeVerifiedAccessEndpointsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DescribeVerifiedAccessEndpointsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DescribeVerifiedAccessEndpointsResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DescribeVerifiedAccessEndpointsCommandError = 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_ec2DescribeVerifiedAccessGroupsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DescribeVerifiedAccessGroupsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DescribeVerifiedAccessGroupsResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DescribeVerifiedAccessGroupsCommandError = 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_ec2DescribeVerifiedAccessInstanceLoggingConfigurationsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DescribeVerifiedAccessInstanceLoggingConfigurationsCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DescribeVerifiedAccessInstanceLoggingConfigurationsResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DescribeVerifiedAccessInstanceLoggingConfigurationsCommandError = 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_ec2DescribeVerifiedAccessInstancesCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DescribeVerifiedAccessInstancesCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DescribeVerifiedAccessInstancesResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DescribeVerifiedAccessInstancesCommandError = 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_ec2DescribeVerifiedAccessTrustProvidersCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DescribeVerifiedAccessTrustProvidersCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DescribeVerifiedAccessTrustProvidersResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DescribeVerifiedAccessTrustProvidersCommandError = 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_ec2DescribeVolumeAttributeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2DescribeVolumeAttributeCommandError(output, context);
@@ -15657,6 +16410,33 @@ const deserializeAws_ec2DetachNetworkInterfaceCommandError = async (output, cont
         errorCode,
     });
 };
+export const deserializeAws_ec2DetachVerifiedAccessTrustProviderCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2DetachVerifiedAccessTrustProviderCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2DetachVerifiedAccessTrustProviderResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2DetachVerifiedAccessTrustProviderCommandError = 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_ec2DetachVolumeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2DetachVolumeCommandError(output, context);
@@ -15735,6 +16515,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 +17154,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 +17316,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 +17661,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);
@@ -17691,6 +18579,60 @@ const deserializeAws_ec2GetTransitGatewayRouteTablePropagationsCommandError = as
         errorCode,
     });
 };
+export const deserializeAws_ec2GetVerifiedAccessEndpointPolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2GetVerifiedAccessEndpointPolicyCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2GetVerifiedAccessEndpointPolicyResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2GetVerifiedAccessEndpointPolicyCommandError = 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_ec2GetVerifiedAccessGroupPolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2GetVerifiedAccessGroupPolicyCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2GetVerifiedAccessGroupPolicyResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2GetVerifiedAccessGroupPolicyCommandError = 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_ec2GetVpnConnectionDeviceSampleConfigurationCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2GetVpnConnectionDeviceSampleConfigurationCommandError(output, context);
@@ -19074,6 +20016,195 @@ const deserializeAws_ec2ModifyTransitGatewayVpcAttachmentCommandError = async (o
         errorCode,
     });
 };
+export const deserializeAws_ec2ModifyVerifiedAccessEndpointCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2ModifyVerifiedAccessEndpointCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2ModifyVerifiedAccessEndpointResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2ModifyVerifiedAccessEndpointCommandError = 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_ec2ModifyVerifiedAccessEndpointPolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2ModifyVerifiedAccessEndpointPolicyCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2ModifyVerifiedAccessEndpointPolicyResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2ModifyVerifiedAccessEndpointPolicyCommandError = 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_ec2ModifyVerifiedAccessGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2ModifyVerifiedAccessGroupCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2ModifyVerifiedAccessGroupResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2ModifyVerifiedAccessGroupCommandError = 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_ec2ModifyVerifiedAccessGroupPolicyCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2ModifyVerifiedAccessGroupPolicyCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2ModifyVerifiedAccessGroupPolicyResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2ModifyVerifiedAccessGroupPolicyCommandError = 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_ec2ModifyVerifiedAccessInstanceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2ModifyVerifiedAccessInstanceCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2ModifyVerifiedAccessInstanceResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2ModifyVerifiedAccessInstanceCommandError = 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_ec2ModifyVerifiedAccessInstanceLoggingConfigurationCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2ModifyVerifiedAccessInstanceLoggingConfigurationCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2ModifyVerifiedAccessInstanceLoggingConfigurationResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2ModifyVerifiedAccessInstanceLoggingConfigurationCommandError = 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_ec2ModifyVerifiedAccessTrustProviderCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return deserializeAws_ec2ModifyVerifiedAccessTrustProviderCommandError(output, context);
+    }
+    const data = await parseBody(output.body, context);
+    let contents = {};
+    contents = deserializeAws_ec2ModifyVerifiedAccessTrustProviderResult(data, context);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return Promise.resolve(response);
+};
+const deserializeAws_ec2ModifyVerifiedAccessTrustProviderCommandError = 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_ec2ModifyVolumeCommand = async (output, context) => {
     if (output.statusCode >= 300) {
         return deserializeAws_ec2ModifyVolumeCommandError(output, context);
@@ -22067,6 +23198,32 @@ 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_ec2AttachVerifiedAccessTrustProviderRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessInstanceId != null) {
+        entries["VerifiedAccessInstanceId"] = input.VerifiedAccessInstanceId;
+    }
+    if (input.VerifiedAccessTrustProviderId != null) {
+        entries["VerifiedAccessTrustProviderId"] = input.VerifiedAccessTrustProviderId;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
     return entries;
 };
 const serializeAws_ec2AttachVolumeRequest = (input, context) => {
@@ -25162,6 +26319,267 @@ const serializeAws_ec2CreateTransitGatewayVpcAttachmentRequestOptions = (input,
     }
     return entries;
 };
+const serializeAws_ec2CreateVerifiedAccessEndpointEniOptions = (input, context) => {
+    const entries = {};
+    if (input.NetworkInterfaceId != null) {
+        entries["NetworkInterfaceId"] = input.NetworkInterfaceId;
+    }
+    if (input.Protocol != null) {
+        entries["Protocol"] = input.Protocol;
+    }
+    if (input.Port != null) {
+        entries["Port"] = input.Port;
+    }
+    return entries;
+};
+const serializeAws_ec2CreateVerifiedAccessEndpointLoadBalancerOptions = (input, context) => {
+    const entries = {};
+    if (input.Protocol != null) {
+        entries["Protocol"] = input.Protocol;
+    }
+    if (input.Port != null) {
+        entries["Port"] = input.Port;
+    }
+    if (input.LoadBalancerArn != null) {
+        entries["LoadBalancerArn"] = input.LoadBalancerArn;
+    }
+    if (input.SubnetIds != null) {
+        const memberEntries = serializeAws_ec2CreateVerifiedAccessEndpointSubnetIdList(input.SubnetIds, context);
+        if (input.SubnetIds?.length === 0) {
+            entries.SubnetId = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `SubnetId.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    return entries;
+};
+const serializeAws_ec2CreateVerifiedAccessEndpointRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessGroupId != null) {
+        entries["VerifiedAccessGroupId"] = input.VerifiedAccessGroupId;
+    }
+    if (input.EndpointType != null) {
+        entries["EndpointType"] = input.EndpointType;
+    }
+    if (input.AttachmentType != null) {
+        entries["AttachmentType"] = input.AttachmentType;
+    }
+    if (input.DomainCertificateArn != null) {
+        entries["DomainCertificateArn"] = input.DomainCertificateArn;
+    }
+    if (input.ApplicationDomain != null) {
+        entries["ApplicationDomain"] = input.ApplicationDomain;
+    }
+    if (input.EndpointDomainPrefix != null) {
+        entries["EndpointDomainPrefix"] = input.EndpointDomainPrefix;
+    }
+    if (input.SecurityGroupIds != null) {
+        const memberEntries = serializeAws_ec2SecurityGroupIdList(input.SecurityGroupIds, context);
+        if (input.SecurityGroupIds?.length === 0) {
+            entries.SecurityGroupId = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `SecurityGroupId.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.LoadBalancerOptions != null) {
+        const memberEntries = serializeAws_ec2CreateVerifiedAccessEndpointLoadBalancerOptions(input.LoadBalancerOptions, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `LoadBalancerOptions.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.NetworkInterfaceOptions != null) {
+        const memberEntries = serializeAws_ec2CreateVerifiedAccessEndpointEniOptions(input.NetworkInterfaceOptions, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `NetworkInterfaceOptions.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.Description != null) {
+        entries["Description"] = input.Description;
+    }
+    if (input.PolicyDocument != null) {
+        entries["PolicyDocument"] = input.PolicyDocument;
+    }
+    if (input.TagSpecifications != null) {
+        const memberEntries = serializeAws_ec2TagSpecificationList(input.TagSpecifications, context);
+        if (input.TagSpecifications?.length === 0) {
+            entries.TagSpecification = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TagSpecification.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2CreateVerifiedAccessEndpointSubnetIdList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`Item.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
+const serializeAws_ec2CreateVerifiedAccessGroupRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessInstanceId != null) {
+        entries["VerifiedAccessInstanceId"] = input.VerifiedAccessInstanceId;
+    }
+    if (input.Description != null) {
+        entries["Description"] = input.Description;
+    }
+    if (input.PolicyDocument != null) {
+        entries["PolicyDocument"] = input.PolicyDocument;
+    }
+    if (input.TagSpecifications != null) {
+        const memberEntries = serializeAws_ec2TagSpecificationList(input.TagSpecifications, context);
+        if (input.TagSpecifications?.length === 0) {
+            entries.TagSpecification = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TagSpecification.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2CreateVerifiedAccessInstanceRequest = (input, context) => {
+    const entries = {};
+    if (input.Description != null) {
+        entries["Description"] = input.Description;
+    }
+    if (input.TagSpecifications != null) {
+        const memberEntries = serializeAws_ec2TagSpecificationList(input.TagSpecifications, context);
+        if (input.TagSpecifications?.length === 0) {
+            entries.TagSpecification = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TagSpecification.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2CreateVerifiedAccessTrustProviderDeviceOptions = (input, context) => {
+    const entries = {};
+    if (input.TenantId != null) {
+        entries["TenantId"] = input.TenantId;
+    }
+    return entries;
+};
+const serializeAws_ec2CreateVerifiedAccessTrustProviderOidcOptions = (input, context) => {
+    const entries = {};
+    if (input.Issuer != null) {
+        entries["Issuer"] = input.Issuer;
+    }
+    if (input.AuthorizationEndpoint != null) {
+        entries["AuthorizationEndpoint"] = input.AuthorizationEndpoint;
+    }
+    if (input.TokenEndpoint != null) {
+        entries["TokenEndpoint"] = input.TokenEndpoint;
+    }
+    if (input.UserInfoEndpoint != null) {
+        entries["UserInfoEndpoint"] = input.UserInfoEndpoint;
+    }
+    if (input.ClientId != null) {
+        entries["ClientId"] = input.ClientId;
+    }
+    if (input.ClientSecret != null) {
+        entries["ClientSecret"] = input.ClientSecret;
+    }
+    if (input.Scope != null) {
+        entries["Scope"] = input.Scope;
+    }
+    return entries;
+};
+const serializeAws_ec2CreateVerifiedAccessTrustProviderRequest = (input, context) => {
+    const entries = {};
+    if (input.TrustProviderType != null) {
+        entries["TrustProviderType"] = input.TrustProviderType;
+    }
+    if (input.UserTrustProviderType != null) {
+        entries["UserTrustProviderType"] = input.UserTrustProviderType;
+    }
+    if (input.DeviceTrustProviderType != null) {
+        entries["DeviceTrustProviderType"] = input.DeviceTrustProviderType;
+    }
+    if (input.OidcOptions != null) {
+        const memberEntries = serializeAws_ec2CreateVerifiedAccessTrustProviderOidcOptions(input.OidcOptions, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `OidcOptions.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.DeviceOptions != null) {
+        const memberEntries = serializeAws_ec2CreateVerifiedAccessTrustProviderDeviceOptions(input.DeviceOptions, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `DeviceOptions.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.PolicyReferenceName != null) {
+        entries["PolicyReferenceName"] = input.PolicyReferenceName;
+    }
+    if (input.Description != null) {
+        entries["Description"] = input.Description;
+    }
+    if (input.TagSpecifications != null) {
+        const memberEntries = serializeAws_ec2TagSpecificationList(input.TagSpecifications, context);
+        if (input.TagSpecifications?.length === 0) {
+            entries.TagSpecification = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TagSpecification.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 const serializeAws_ec2CreateVolumePermission = (input, context) => {
     const entries = {};
     if (input.Group != null) {
@@ -25591,6 +27009,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;
@@ -26308,6 +27763,70 @@ const serializeAws_ec2DeleteTransitGatewayVpcAttachmentRequest = (input, context
     }
     return entries;
 };
+const serializeAws_ec2DeleteVerifiedAccessEndpointRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessEndpointId != null) {
+        entries["VerifiedAccessEndpointId"] = input.VerifiedAccessEndpointId;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2DeleteVerifiedAccessGroupRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessGroupId != null) {
+        entries["VerifiedAccessGroupId"] = input.VerifiedAccessGroupId;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2DeleteVerifiedAccessInstanceRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessInstanceId != null) {
+        entries["VerifiedAccessInstanceId"] = input.VerifiedAccessInstanceId;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    return entries;
+};
+const serializeAws_ec2DeleteVerifiedAccessTrustProviderRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessTrustProviderId != null) {
+        entries["VerifiedAccessTrustProviderId"] = input.VerifiedAccessTrustProviderId;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    return entries;
+};
 const serializeAws_ec2DeleteVolumeRequest = (input, context) => {
     const entries = {};
     if (input.VolumeId != null) {
@@ -26692,6 +28211,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) {
@@ -29848,7 +31390,238 @@ const serializeAws_ec2DescribeTransitGatewayConnectPeersRequest = (input, contex
     }
     return entries;
 };
-const serializeAws_ec2DescribeTransitGatewayConnectsRequest = (input, context) => {
+const serializeAws_ec2DescribeTransitGatewayConnectsRequest = (input, context) => {
+    const entries = {};
+    if (input.TransitGatewayAttachmentIds != null) {
+        const memberEntries = serializeAws_ec2TransitGatewayAttachmentIdStringList(input.TransitGatewayAttachmentIds, context);
+        if (input.TransitGatewayAttachmentIds?.length === 0) {
+            entries.TransitGatewayAttachmentIds = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TransitGatewayAttachmentIds.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    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.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_ec2DescribeTransitGatewayMulticastDomainsRequest = (input, context) => {
+    const entries = {};
+    if (input.TransitGatewayMulticastDomainIds != null) {
+        const memberEntries = serializeAws_ec2TransitGatewayMulticastDomainIdStringList(input.TransitGatewayMulticastDomainIds, context);
+        if (input.TransitGatewayMulticastDomainIds?.length === 0) {
+            entries.TransitGatewayMulticastDomainIds = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TransitGatewayMulticastDomainIds.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    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.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_ec2DescribeTransitGatewayPeeringAttachmentsRequest = (input, context) => {
+    const entries = {};
+    if (input.TransitGatewayAttachmentIds != null) {
+        const memberEntries = serializeAws_ec2TransitGatewayAttachmentIdStringList(input.TransitGatewayAttachmentIds, context);
+        if (input.TransitGatewayAttachmentIds?.length === 0) {
+            entries.TransitGatewayAttachmentIds = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TransitGatewayAttachmentIds.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    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.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_ec2DescribeTransitGatewayPolicyTablesRequest = (input, context) => {
+    const entries = {};
+    if (input.TransitGatewayPolicyTableIds != null) {
+        const memberEntries = serializeAws_ec2TransitGatewayPolicyTableIdStringList(input.TransitGatewayPolicyTableIds, context);
+        if (input.TransitGatewayPolicyTableIds?.length === 0) {
+            entries.TransitGatewayPolicyTableIds = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TransitGatewayPolicyTableIds.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    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.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_ec2DescribeTransitGatewayRouteTableAnnouncementsRequest = (input, context) => {
+    const entries = {};
+    if (input.TransitGatewayRouteTableAnnouncementIds != null) {
+        const memberEntries = serializeAws_ec2TransitGatewayRouteTableAnnouncementIdStringList(input.TransitGatewayRouteTableAnnouncementIds, context);
+        if (input.TransitGatewayRouteTableAnnouncementIds?.length === 0) {
+            entries.TransitGatewayRouteTableAnnouncementIds = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TransitGatewayRouteTableAnnouncementIds.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    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.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_ec2DescribeTransitGatewayRouteTablesRequest = (input, context) => {
+    const entries = {};
+    if (input.TransitGatewayRouteTableIds != null) {
+        const memberEntries = serializeAws_ec2TransitGatewayRouteTableIdStringList(input.TransitGatewayRouteTableIds, context);
+        if (input.TransitGatewayRouteTableIds?.length === 0) {
+            entries.TransitGatewayRouteTableIds = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TransitGatewayRouteTableIds.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    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.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_ec2DescribeTransitGatewaysRequest = (input, context) => {
+    const entries = {};
+    if (input.TransitGatewayIds != null) {
+        const memberEntries = serializeAws_ec2TransitGatewayIdStringList(input.TransitGatewayIds, context);
+        if (input.TransitGatewayIds?.length === 0) {
+            entries.TransitGatewayIds = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `TransitGatewayIds.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    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.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_ec2DescribeTransitGatewayVpcAttachmentsRequest = (input, context) => {
     const entries = {};
     if (input.TransitGatewayAttachmentIds != null) {
         const memberEntries = serializeAws_ec2TransitGatewayAttachmentIdStringList(input.TransitGatewayAttachmentIds, context);
@@ -29881,18 +31654,21 @@ const serializeAws_ec2DescribeTransitGatewayConnectsRequest = (input, context) =
     }
     return entries;
 };
-const serializeAws_ec2DescribeTransitGatewayMulticastDomainsRequest = (input, context) => {
+const serializeAws_ec2DescribeTrunkInterfaceAssociationsRequest = (input, context) => {
     const entries = {};
-    if (input.TransitGatewayMulticastDomainIds != null) {
-        const memberEntries = serializeAws_ec2TransitGatewayMulticastDomainIdStringList(input.TransitGatewayMulticastDomainIds, context);
-        if (input.TransitGatewayMulticastDomainIds?.length === 0) {
-            entries.TransitGatewayMulticastDomainIds = [];
+    if (input.AssociationIds != null) {
+        const memberEntries = serializeAws_ec2TrunkInterfaceAssociationIdList(input.AssociationIds, context);
+        if (input.AssociationIds?.length === 0) {
+            entries.AssociationId = [];
         }
         Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `TransitGatewayMulticastDomainIds.${key.substring(key.indexOf(".") + 1)}`;
+            const loc = `AssociationId.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
     if (input.Filters != null) {
         const memberEntries = serializeAws_ec2FilterList(input.Filters, context);
         if (input.Filters?.length === 0) {
@@ -29903,38 +31679,31 @@ const serializeAws_ec2DescribeTransitGatewayMulticastDomainsRequest = (input, co
             entries[loc] = value;
         });
     }
-    if (input.MaxResults != null) {
-        entries["MaxResults"] = input.MaxResults;
-    }
     if (input.NextToken != null) {
         entries["NextToken"] = input.NextToken;
     }
-    if (input.DryRun != null) {
-        entries["DryRun"] = input.DryRun;
+    if (input.MaxResults != null) {
+        entries["MaxResults"] = input.MaxResults;
     }
     return entries;
 };
-const serializeAws_ec2DescribeTransitGatewayPeeringAttachmentsRequest = (input, context) => {
+const serializeAws_ec2DescribeVerifiedAccessEndpointsRequest = (input, context) => {
     const entries = {};
-    if (input.TransitGatewayAttachmentIds != null) {
-        const memberEntries = serializeAws_ec2TransitGatewayAttachmentIdStringList(input.TransitGatewayAttachmentIds, context);
-        if (input.TransitGatewayAttachmentIds?.length === 0) {
-            entries.TransitGatewayAttachmentIds = [];
+    if (input.VerifiedAccessEndpointIds != null) {
+        const memberEntries = serializeAws_ec2VerifiedAccessEndpointIdList(input.VerifiedAccessEndpointIds, context);
+        if (input.VerifiedAccessEndpointIds?.length === 0) {
+            entries.VerifiedAccessEndpointId = [];
         }
         Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `TransitGatewayAttachmentIds.${key.substring(key.indexOf(".") + 1)}`;
+            const loc = `VerifiedAccessEndpointId.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
-    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.VerifiedAccessInstanceId != null) {
+        entries["VerifiedAccessInstanceId"] = input.VerifiedAccessInstanceId;
+    }
+    if (input.VerifiedAccessGroupId != null) {
+        entries["VerifiedAccessGroupId"] = input.VerifiedAccessGroupId;
     }
     if (input.MaxResults != null) {
         entries["MaxResults"] = input.MaxResults;
@@ -29942,23 +31711,6 @@ const serializeAws_ec2DescribeTransitGatewayPeeringAttachmentsRequest = (input,
     if (input.NextToken != null) {
         entries["NextToken"] = input.NextToken;
     }
-    if (input.DryRun != null) {
-        entries["DryRun"] = input.DryRun;
-    }
-    return entries;
-};
-const serializeAws_ec2DescribeTransitGatewayPolicyTablesRequest = (input, context) => {
-    const entries = {};
-    if (input.TransitGatewayPolicyTableIds != null) {
-        const memberEntries = serializeAws_ec2TransitGatewayPolicyTableIdStringList(input.TransitGatewayPolicyTableIds, context);
-        if (input.TransitGatewayPolicyTableIds?.length === 0) {
-            entries.TransitGatewayPolicyTableIds = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `TransitGatewayPolicyTableIds.${key.substring(key.indexOf(".") + 1)}`;
-            entries[loc] = value;
-        });
-    }
     if (input.Filters != null) {
         const memberEntries = serializeAws_ec2FilterList(input.Filters, context);
         if (input.Filters?.length === 0) {
@@ -29969,38 +31721,25 @@ const serializeAws_ec2DescribeTransitGatewayPolicyTablesRequest = (input, contex
             entries[loc] = value;
         });
     }
-    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_ec2DescribeTransitGatewayRouteTableAnnouncementsRequest = (input, context) => {
+const serializeAws_ec2DescribeVerifiedAccessGroupsRequest = (input, context) => {
     const entries = {};
-    if (input.TransitGatewayRouteTableAnnouncementIds != null) {
-        const memberEntries = serializeAws_ec2TransitGatewayRouteTableAnnouncementIdStringList(input.TransitGatewayRouteTableAnnouncementIds, context);
-        if (input.TransitGatewayRouteTableAnnouncementIds?.length === 0) {
-            entries.TransitGatewayRouteTableAnnouncementIds = [];
+    if (input.VerifiedAccessGroupIds != null) {
+        const memberEntries = serializeAws_ec2VerifiedAccessGroupIdList(input.VerifiedAccessGroupIds, context);
+        if (input.VerifiedAccessGroupIds?.length === 0) {
+            entries.VerifiedAccessGroupId = [];
         }
         Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `TransitGatewayRouteTableAnnouncementIds.${key.substring(key.indexOf(".") + 1)}`;
+            const loc = `VerifiedAccessGroupId.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
-    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.VerifiedAccessInstanceId != null) {
+        entries["VerifiedAccessInstanceId"] = input.VerifiedAccessInstanceId;
     }
     if (input.MaxResults != null) {
         entries["MaxResults"] = input.MaxResults;
@@ -30008,23 +31747,6 @@ const serializeAws_ec2DescribeTransitGatewayRouteTableAnnouncementsRequest = (in
     if (input.NextToken != null) {
         entries["NextToken"] = input.NextToken;
     }
-    if (input.DryRun != null) {
-        entries["DryRun"] = input.DryRun;
-    }
-    return entries;
-};
-const serializeAws_ec2DescribeTransitGatewayRouteTablesRequest = (input, context) => {
-    const entries = {};
-    if (input.TransitGatewayRouteTableIds != null) {
-        const memberEntries = serializeAws_ec2TransitGatewayRouteTableIdStringList(input.TransitGatewayRouteTableIds, context);
-        if (input.TransitGatewayRouteTableIds?.length === 0) {
-            entries.TransitGatewayRouteTableIds = [];
-        }
-        Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `TransitGatewayRouteTableIds.${key.substring(key.indexOf(".") + 1)}`;
-            entries[loc] = value;
-        });
-    }
     if (input.Filters != null) {
         const memberEntries = serializeAws_ec2FilterList(input.Filters, context);
         if (input.Filters?.length === 0) {
@@ -30035,29 +31757,29 @@ const serializeAws_ec2DescribeTransitGatewayRouteTablesRequest = (input, context
             entries[loc] = value;
         });
     }
-    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_ec2DescribeTransitGatewaysRequest = (input, context) => {
+const serializeAws_ec2DescribeVerifiedAccessInstanceLoggingConfigurationsRequest = (input, context) => {
     const entries = {};
-    if (input.TransitGatewayIds != null) {
-        const memberEntries = serializeAws_ec2TransitGatewayIdStringList(input.TransitGatewayIds, context);
-        if (input.TransitGatewayIds?.length === 0) {
-            entries.TransitGatewayIds = [];
+    if (input.VerifiedAccessInstanceIds != null) {
+        const memberEntries = serializeAws_ec2VerifiedAccessInstanceIdList(input.VerifiedAccessInstanceIds, context);
+        if (input.VerifiedAccessInstanceIds?.length === 0) {
+            entries.VerifiedAccessInstanceId = [];
         }
         Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `TransitGatewayIds.${key.substring(key.indexOf(".") + 1)}`;
+            const loc = `VerifiedAccessInstanceId.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
+    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) {
@@ -30068,29 +31790,29 @@ const serializeAws_ec2DescribeTransitGatewaysRequest = (input, context) => {
             entries[loc] = value;
         });
     }
-    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_ec2DescribeTransitGatewayVpcAttachmentsRequest = (input, context) => {
+const serializeAws_ec2DescribeVerifiedAccessInstancesRequest = (input, context) => {
     const entries = {};
-    if (input.TransitGatewayAttachmentIds != null) {
-        const memberEntries = serializeAws_ec2TransitGatewayAttachmentIdStringList(input.TransitGatewayAttachmentIds, context);
-        if (input.TransitGatewayAttachmentIds?.length === 0) {
-            entries.TransitGatewayAttachmentIds = [];
+    if (input.VerifiedAccessInstanceIds != null) {
+        const memberEntries = serializeAws_ec2VerifiedAccessInstanceIdList(input.VerifiedAccessInstanceIds, context);
+        if (input.VerifiedAccessInstanceIds?.length === 0) {
+            entries.VerifiedAccessInstanceId = [];
         }
         Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `TransitGatewayAttachmentIds.${key.substring(key.indexOf(".") + 1)}`;
+            const loc = `VerifiedAccessInstanceId.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
+    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) {
@@ -30101,31 +31823,28 @@ const serializeAws_ec2DescribeTransitGatewayVpcAttachmentsRequest = (input, cont
             entries[loc] = value;
         });
     }
-    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_ec2DescribeTrunkInterfaceAssociationsRequest = (input, context) => {
+const serializeAws_ec2DescribeVerifiedAccessTrustProvidersRequest = (input, context) => {
     const entries = {};
-    if (input.AssociationIds != null) {
-        const memberEntries = serializeAws_ec2TrunkInterfaceAssociationIdList(input.AssociationIds, context);
-        if (input.AssociationIds?.length === 0) {
-            entries.AssociationId = [];
+    if (input.VerifiedAccessTrustProviderIds != null) {
+        const memberEntries = serializeAws_ec2VerifiedAccessTrustProviderIdList(input.VerifiedAccessTrustProviderIds, context);
+        if (input.VerifiedAccessTrustProviderIds?.length === 0) {
+            entries.VerifiedAccessTrustProviderId = [];
         }
         Object.entries(memberEntries).forEach(([key, value]) => {
-            const loc = `AssociationId.${key.substring(key.indexOf(".") + 1)}`;
+            const loc = `VerifiedAccessTrustProviderId.${key.substring(key.indexOf(".") + 1)}`;
             entries[loc] = value;
         });
     }
-    if (input.DryRun != null) {
-        entries["DryRun"] = input.DryRun;
+    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);
@@ -30137,11 +31856,8 @@ const serializeAws_ec2DescribeTrunkInterfaceAssociationsRequest = (input, contex
             entries[loc] = value;
         });
     }
-    if (input.NextToken != null) {
-        entries["NextToken"] = input.NextToken;
-    }
-    if (input.MaxResults != null) {
-        entries["MaxResults"] = input.MaxResults;
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
     }
     return entries;
 };
@@ -30663,6 +32379,25 @@ const serializeAws_ec2DetachNetworkInterfaceRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2DetachVerifiedAccessTrustProviderRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessInstanceId != null) {
+        entries["VerifiedAccessInstanceId"] = input.VerifiedAccessInstanceId;
+    }
+    if (input.VerifiedAccessTrustProviderId != null) {
+        entries["VerifiedAccessTrustProviderId"] = input.VerifiedAccessTrustProviderId;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 const serializeAws_ec2DetachVolumeRequest = (input, context) => {
     const entries = {};
     if (input.Device != null) {
@@ -30724,6 +32459,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 +32963,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 +33069,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 +33139,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 +33611,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) {
@@ -32505,6 +34335,26 @@ const serializeAws_ec2GetTransitGatewayRouteTablePropagationsRequest = (input, c
     }
     return entries;
 };
+const serializeAws_ec2GetVerifiedAccessEndpointPolicyRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessEndpointId != null) {
+        entries["VerifiedAccessEndpointId"] = input.VerifiedAccessEndpointId;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2GetVerifiedAccessGroupPolicyRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessGroupId != null) {
+        entries["VerifiedAccessGroupId"] = input.VerifiedAccessGroupId;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
 const serializeAws_ec2GetVpnConnectionDeviceSampleConfigurationRequest = (input, context) => {
     const entries = {};
     if (input.VpnConnectionId != null) {
@@ -35879,6 +37729,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) => {
@@ -36357,6 +38214,225 @@ const serializeAws_ec2ModifyTransitGatewayVpcAttachmentRequestOptions = (input,
     }
     return entries;
 };
+const serializeAws_ec2ModifyVerifiedAccessEndpointEniOptions = (input, context) => {
+    const entries = {};
+    if (input.Protocol != null) {
+        entries["Protocol"] = input.Protocol;
+    }
+    if (input.Port != null) {
+        entries["Port"] = input.Port;
+    }
+    return entries;
+};
+const serializeAws_ec2ModifyVerifiedAccessEndpointLoadBalancerOptions = (input, context) => {
+    const entries = {};
+    if (input.SubnetIds != null) {
+        const memberEntries = serializeAws_ec2ModifyVerifiedAccessEndpointSubnetIdList(input.SubnetIds, context);
+        if (input.SubnetIds?.length === 0) {
+            entries.SubnetId = [];
+        }
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `SubnetId.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.Protocol != null) {
+        entries["Protocol"] = input.Protocol;
+    }
+    if (input.Port != null) {
+        entries["Port"] = input.Port;
+    }
+    return entries;
+};
+const serializeAws_ec2ModifyVerifiedAccessEndpointPolicyRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessEndpointId != null) {
+        entries["VerifiedAccessEndpointId"] = input.VerifiedAccessEndpointId;
+    }
+    if (input.PolicyEnabled != null) {
+        entries["PolicyEnabled"] = input.PolicyEnabled;
+    }
+    if (input.PolicyDocument != null) {
+        entries["PolicyDocument"] = input.PolicyDocument;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2ModifyVerifiedAccessEndpointRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessEndpointId != null) {
+        entries["VerifiedAccessEndpointId"] = input.VerifiedAccessEndpointId;
+    }
+    if (input.VerifiedAccessGroupId != null) {
+        entries["VerifiedAccessGroupId"] = input.VerifiedAccessGroupId;
+    }
+    if (input.LoadBalancerOptions != null) {
+        const memberEntries = serializeAws_ec2ModifyVerifiedAccessEndpointLoadBalancerOptions(input.LoadBalancerOptions, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `LoadBalancerOptions.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.NetworkInterfaceOptions != null) {
+        const memberEntries = serializeAws_ec2ModifyVerifiedAccessEndpointEniOptions(input.NetworkInterfaceOptions, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `NetworkInterfaceOptions.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.Description != null) {
+        entries["Description"] = input.Description;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2ModifyVerifiedAccessEndpointSubnetIdList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`Item.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
+const serializeAws_ec2ModifyVerifiedAccessGroupPolicyRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessGroupId != null) {
+        entries["VerifiedAccessGroupId"] = input.VerifiedAccessGroupId;
+    }
+    if (input.PolicyEnabled != null) {
+        entries["PolicyEnabled"] = input.PolicyEnabled;
+    }
+    if (input.PolicyDocument != null) {
+        entries["PolicyDocument"] = input.PolicyDocument;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2ModifyVerifiedAccessGroupRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessGroupId != null) {
+        entries["VerifiedAccessGroupId"] = input.VerifiedAccessGroupId;
+    }
+    if (input.VerifiedAccessInstanceId != null) {
+        entries["VerifiedAccessInstanceId"] = input.VerifiedAccessInstanceId;
+    }
+    if (input.Description != null) {
+        entries["Description"] = input.Description;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2ModifyVerifiedAccessInstanceLoggingConfigurationRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessInstanceId != null) {
+        entries["VerifiedAccessInstanceId"] = input.VerifiedAccessInstanceId;
+    }
+    if (input.AccessLogs != null) {
+        const memberEntries = serializeAws_ec2VerifiedAccessLogOptions(input.AccessLogs, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `AccessLogs.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    return entries;
+};
+const serializeAws_ec2ModifyVerifiedAccessInstanceRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessInstanceId != null) {
+        entries["VerifiedAccessInstanceId"] = input.VerifiedAccessInstanceId;
+    }
+    if (input.Description != null) {
+        entries["Description"] = input.Description;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    return entries;
+};
+const serializeAws_ec2ModifyVerifiedAccessTrustProviderOidcOptions = (input, context) => {
+    const entries = {};
+    if (input.Scope != null) {
+        entries["Scope"] = input.Scope;
+    }
+    return entries;
+};
+const serializeAws_ec2ModifyVerifiedAccessTrustProviderRequest = (input, context) => {
+    const entries = {};
+    if (input.VerifiedAccessTrustProviderId != null) {
+        entries["VerifiedAccessTrustProviderId"] = input.VerifiedAccessTrustProviderId;
+    }
+    if (input.OidcOptions != null) {
+        const memberEntries = serializeAws_ec2ModifyVerifiedAccessTrustProviderOidcOptions(input.OidcOptions, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `OidcOptions.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.Description != null) {
+        entries["Description"] = input.Description;
+    }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    if (input.ClientToken === undefined) {
+        input.ClientToken = generateIdempotencyToken();
+    }
+    if (input.ClientToken != null) {
+        entries["ClientToken"] = input.ClientToken;
+    }
+    return entries;
+};
 const serializeAws_ec2ModifyVolumeAttributeRequest = (input, context) => {
     const entries = {};
     if (input.AutoEnableIO != null) {
@@ -40055,6 +42131,18 @@ const serializeAws_ec2SearchTransitGatewayRoutesRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2SecurityGroupIdList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`Item.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
 const serializeAws_ec2SecurityGroupIdStringList = (input, context) => {
     const entries = {};
     let counter = 1;
@@ -40650,6 +42738,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) {
@@ -41469,6 +43567,115 @@ const serializeAws_ec2VCpuCountRangeRequest = (input, context) => {
     }
     return entries;
 };
+const serializeAws_ec2VerifiedAccessEndpointIdList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`Item.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
+const serializeAws_ec2VerifiedAccessGroupIdList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`Item.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
+const serializeAws_ec2VerifiedAccessInstanceIdList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`Item.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
+const serializeAws_ec2VerifiedAccessLogCloudWatchLogsDestinationOptions = (input, context) => {
+    const entries = {};
+    if (input.Enabled != null) {
+        entries["Enabled"] = input.Enabled;
+    }
+    if (input.LogGroup != null) {
+        entries["LogGroup"] = input.LogGroup;
+    }
+    return entries;
+};
+const serializeAws_ec2VerifiedAccessLogKinesisDataFirehoseDestinationOptions = (input, context) => {
+    const entries = {};
+    if (input.Enabled != null) {
+        entries["Enabled"] = input.Enabled;
+    }
+    if (input.DeliveryStream != null) {
+        entries["DeliveryStream"] = input.DeliveryStream;
+    }
+    return entries;
+};
+const serializeAws_ec2VerifiedAccessLogOptions = (input, context) => {
+    const entries = {};
+    if (input.S3 != null) {
+        const memberEntries = serializeAws_ec2VerifiedAccessLogS3DestinationOptions(input.S3, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `S3.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.CloudWatchLogs != null) {
+        const memberEntries = serializeAws_ec2VerifiedAccessLogCloudWatchLogsDestinationOptions(input.CloudWatchLogs, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `CloudWatchLogs.${key}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.KinesisDataFirehose != null) {
+        const memberEntries = serializeAws_ec2VerifiedAccessLogKinesisDataFirehoseDestinationOptions(input.KinesisDataFirehose, context);
+        Object.entries(memberEntries).forEach(([key, value]) => {
+            const loc = `KinesisDataFirehose.${key}`;
+            entries[loc] = value;
+        });
+    }
+    return entries;
+};
+const serializeAws_ec2VerifiedAccessLogS3DestinationOptions = (input, context) => {
+    const entries = {};
+    if (input.Enabled != null) {
+        entries["Enabled"] = input.Enabled;
+    }
+    if (input.BucketName != null) {
+        entries["BucketName"] = input.BucketName;
+    }
+    if (input.Prefix != null) {
+        entries["Prefix"] = input.Prefix;
+    }
+    if (input.BucketOwner != null) {
+        entries["BucketOwner"] = input.BucketOwner;
+    }
+    return entries;
+};
+const serializeAws_ec2VerifiedAccessTrustProviderIdList = (input, context) => {
+    const entries = {};
+    let counter = 1;
+    for (const entry of input) {
+        if (entry === null) {
+            continue;
+        }
+        entries[`Item.${counter}`] = entry;
+        counter++;
+    }
+    return entries;
+};
 const serializeAws_ec2VersionStringList = (input, context) => {
     const entries = {};
     let counter = 1;
@@ -42899,6 +45106,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,
@@ -42912,6 +45141,19 @@ const deserializeAws_ec2AttachNetworkInterfaceResult = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2AttachVerifiedAccessTrustProviderResult = (output, context) => {
+    const contents = {
+        VerifiedAccessTrustProvider: undefined,
+        VerifiedAccessInstance: undefined,
+    };
+    if (output["verifiedAccessTrustProvider"] !== undefined) {
+        contents.VerifiedAccessTrustProvider = deserializeAws_ec2VerifiedAccessTrustProvider(output["verifiedAccessTrustProvider"], context);
+    }
+    if (output["verifiedAccessInstance"] !== undefined) {
+        contents.VerifiedAccessInstance = deserializeAws_ec2VerifiedAccessInstance(output["verifiedAccessInstance"], context);
+    }
+    return contents;
+};
 const deserializeAws_ec2AttachVpnGatewayResult = (output, context) => {
     const contents = {
         VpcAttachment: undefined,
@@ -45286,6 +47528,42 @@ const deserializeAws_ec2CreateTransitGatewayVpcAttachmentResult = (output, conte
     }
     return contents;
 };
+const deserializeAws_ec2CreateVerifiedAccessEndpointResult = (output, context) => {
+    const contents = {
+        VerifiedAccessEndpoint: undefined,
+    };
+    if (output["verifiedAccessEndpoint"] !== undefined) {
+        contents.VerifiedAccessEndpoint = deserializeAws_ec2VerifiedAccessEndpoint(output["verifiedAccessEndpoint"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2CreateVerifiedAccessGroupResult = (output, context) => {
+    const contents = {
+        VerifiedAccessGroup: undefined,
+    };
+    if (output["verifiedAccessGroup"] !== undefined) {
+        contents.VerifiedAccessGroup = deserializeAws_ec2VerifiedAccessGroup(output["verifiedAccessGroup"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2CreateVerifiedAccessInstanceResult = (output, context) => {
+    const contents = {
+        VerifiedAccessInstance: undefined,
+    };
+    if (output["verifiedAccessInstance"] !== undefined) {
+        contents.VerifiedAccessInstance = deserializeAws_ec2VerifiedAccessInstance(output["verifiedAccessInstance"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2CreateVerifiedAccessTrustProviderResult = (output, context) => {
+    const contents = {
+        VerifiedAccessTrustProvider: undefined,
+    };
+    if (output["verifiedAccessTrustProvider"] !== undefined) {
+        contents.VerifiedAccessTrustProvider = deserializeAws_ec2VerifiedAccessTrustProvider(output["verifiedAccessTrustProvider"], context);
+    }
+    return contents;
+};
 const deserializeAws_ec2CreateVolumePermission = (output, context) => {
     const contents = {
         Group: undefined,
@@ -45437,6 +47715,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)
@@ -46004,6 +48325,42 @@ const deserializeAws_ec2DeleteTransitGatewayVpcAttachmentResult = (output, conte
     }
     return contents;
 };
+const deserializeAws_ec2DeleteVerifiedAccessEndpointResult = (output, context) => {
+    const contents = {
+        VerifiedAccessEndpoint: undefined,
+    };
+    if (output["verifiedAccessEndpoint"] !== undefined) {
+        contents.VerifiedAccessEndpoint = deserializeAws_ec2VerifiedAccessEndpoint(output["verifiedAccessEndpoint"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2DeleteVerifiedAccessGroupResult = (output, context) => {
+    const contents = {
+        VerifiedAccessGroup: undefined,
+    };
+    if (output["verifiedAccessGroup"] !== undefined) {
+        contents.VerifiedAccessGroup = deserializeAws_ec2VerifiedAccessGroup(output["verifiedAccessGroup"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2DeleteVerifiedAccessInstanceResult = (output, context) => {
+    const contents = {
+        VerifiedAccessInstance: undefined,
+    };
+    if (output["verifiedAccessInstance"] !== undefined) {
+        contents.VerifiedAccessInstance = deserializeAws_ec2VerifiedAccessInstance(output["verifiedAccessInstance"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2DeleteVerifiedAccessTrustProviderResult = (output, context) => {
+    const contents = {
+        VerifiedAccessTrustProvider: undefined,
+    };
+    if (output["verifiedAccessTrustProvider"] !== undefined) {
+        contents.VerifiedAccessTrustProvider = deserializeAws_ec2VerifiedAccessTrustProvider(output["verifiedAccessTrustProvider"], context);
+    }
+    return contents;
+};
 const deserializeAws_ec2DeleteVpcEndpointConnectionNotificationsResult = (output, context) => {
     const contents = {
         Unsuccessful: undefined,
@@ -46202,6 +48559,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,
@@ -48170,6 +50543,90 @@ const deserializeAws_ec2DescribeTrunkInterfaceAssociationsResult = (output, cont
     }
     return contents;
 };
+const deserializeAws_ec2DescribeVerifiedAccessEndpointsResult = (output, context) => {
+    const contents = {
+        VerifiedAccessEndpoints: undefined,
+        NextToken: undefined,
+    };
+    if (output.verifiedAccessEndpointSet === "") {
+        contents.VerifiedAccessEndpoints = [];
+    }
+    else if (output["verifiedAccessEndpointSet"] !== undefined &&
+        output["verifiedAccessEndpointSet"]["item"] !== undefined) {
+        contents.VerifiedAccessEndpoints = deserializeAws_ec2VerifiedAccessEndpointList(__getArrayIfSingleItem(output["verifiedAccessEndpointSet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2DescribeVerifiedAccessGroupsResult = (output, context) => {
+    const contents = {
+        VerifiedAccessGroups: undefined,
+        NextToken: undefined,
+    };
+    if (output.verifiedAccessGroupSet === "") {
+        contents.VerifiedAccessGroups = [];
+    }
+    else if (output["verifiedAccessGroupSet"] !== undefined && output["verifiedAccessGroupSet"]["item"] !== undefined) {
+        contents.VerifiedAccessGroups = deserializeAws_ec2VerifiedAccessGroupList(__getArrayIfSingleItem(output["verifiedAccessGroupSet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2DescribeVerifiedAccessInstanceLoggingConfigurationsResult = (output, context) => {
+    const contents = {
+        LoggingConfigurations: undefined,
+        NextToken: undefined,
+    };
+    if (output.loggingConfigurationSet === "") {
+        contents.LoggingConfigurations = [];
+    }
+    else if (output["loggingConfigurationSet"] !== undefined &&
+        output["loggingConfigurationSet"]["item"] !== undefined) {
+        contents.LoggingConfigurations = deserializeAws_ec2VerifiedAccessInstanceLoggingConfigurationList(__getArrayIfSingleItem(output["loggingConfigurationSet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2DescribeVerifiedAccessInstancesResult = (output, context) => {
+    const contents = {
+        VerifiedAccessInstances: undefined,
+        NextToken: undefined,
+    };
+    if (output.verifiedAccessInstanceSet === "") {
+        contents.VerifiedAccessInstances = [];
+    }
+    else if (output["verifiedAccessInstanceSet"] !== undefined &&
+        output["verifiedAccessInstanceSet"]["item"] !== undefined) {
+        contents.VerifiedAccessInstances = deserializeAws_ec2VerifiedAccessInstanceList(__getArrayIfSingleItem(output["verifiedAccessInstanceSet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2DescribeVerifiedAccessTrustProvidersResult = (output, context) => {
+    const contents = {
+        VerifiedAccessTrustProviders: undefined,
+        NextToken: undefined,
+    };
+    if (output.verifiedAccessTrustProviderSet === "") {
+        contents.VerifiedAccessTrustProviders = [];
+    }
+    else if (output["verifiedAccessTrustProviderSet"] !== undefined &&
+        output["verifiedAccessTrustProviderSet"]["item"] !== undefined) {
+        contents.VerifiedAccessTrustProviders = deserializeAws_ec2VerifiedAccessTrustProviderList(__getArrayIfSingleItem(output["verifiedAccessTrustProviderSet"]["item"]), context);
+    }
+    if (output["nextToken"] !== undefined) {
+        contents.NextToken = __expectString(output["nextToken"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2DescribeVolumeAttributeResult = (output, context) => {
     const contents = {
         AutoEnableIO: undefined,
@@ -48476,6 +50933,28 @@ const deserializeAws_ec2DetachClassicLinkVpcResult = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2DetachVerifiedAccessTrustProviderResult = (output, context) => {
+    const contents = {
+        VerifiedAccessTrustProvider: undefined,
+        VerifiedAccessInstance: undefined,
+    };
+    if (output["verifiedAccessTrustProvider"] !== undefined) {
+        contents.VerifiedAccessTrustProvider = deserializeAws_ec2VerifiedAccessTrustProvider(output["verifiedAccessTrustProvider"], context);
+    }
+    if (output["verifiedAccessInstance"] !== undefined) {
+        contents.VerifiedAccessInstance = deserializeAws_ec2VerifiedAccessInstance(output["verifiedAccessInstance"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2DeviceOptions = (output, context) => {
+    const contents = {
+        TenantId: undefined,
+    };
+    if (output["tenantId"] !== undefined) {
+        contents.TenantId = __expectString(output["tenantId"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2DhcpConfiguration = (output, context) => {
     const contents = {
         Key: undefined,
@@ -48558,6 +51037,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 +51763,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 +51972,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 +53140,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,
@@ -51194,6 +53716,32 @@ const deserializeAws_ec2GetTransitGatewayRouteTablePropagationsResult = (output,
     }
     return contents;
 };
+const deserializeAws_ec2GetVerifiedAccessEndpointPolicyResult = (output, context) => {
+    const contents = {
+        PolicyEnabled: undefined,
+        PolicyDocument: undefined,
+    };
+    if (output["policyEnabled"] !== undefined) {
+        contents.PolicyEnabled = __parseBoolean(output["policyEnabled"]);
+    }
+    if (output["policyDocument"] !== undefined) {
+        contents.PolicyDocument = __expectString(output["policyDocument"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2GetVerifiedAccessGroupPolicyResult = (output, context) => {
+    const contents = {
+        PolicyEnabled: undefined,
+        PolicyDocument: undefined,
+    };
+    if (output["policyEnabled"] !== undefined) {
+        contents.PolicyEnabled = __parseBoolean(output["policyEnabled"]);
+    }
+    if (output["policyDocument"] !== undefined) {
+        contents.PolicyDocument = __expectString(output["policyDocument"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2GetVpnConnectionDeviceSampleConfigurationResult = (output, context) => {
     const contents = {
         VpnConnectionDeviceSampleConfiguration: undefined,
@@ -55976,6 +58524,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,
@@ -56325,6 +58901,77 @@ const deserializeAws_ec2ModifyTransitGatewayVpcAttachmentResult = (output, conte
     }
     return contents;
 };
+const deserializeAws_ec2ModifyVerifiedAccessEndpointPolicyResult = (output, context) => {
+    const contents = {
+        PolicyEnabled: undefined,
+        PolicyDocument: undefined,
+    };
+    if (output["policyEnabled"] !== undefined) {
+        contents.PolicyEnabled = __parseBoolean(output["policyEnabled"]);
+    }
+    if (output["policyDocument"] !== undefined) {
+        contents.PolicyDocument = __expectString(output["policyDocument"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2ModifyVerifiedAccessEndpointResult = (output, context) => {
+    const contents = {
+        VerifiedAccessEndpoint: undefined,
+    };
+    if (output["verifiedAccessEndpoint"] !== undefined) {
+        contents.VerifiedAccessEndpoint = deserializeAws_ec2VerifiedAccessEndpoint(output["verifiedAccessEndpoint"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2ModifyVerifiedAccessGroupPolicyResult = (output, context) => {
+    const contents = {
+        PolicyEnabled: undefined,
+        PolicyDocument: undefined,
+    };
+    if (output["policyEnabled"] !== undefined) {
+        contents.PolicyEnabled = __parseBoolean(output["policyEnabled"]);
+    }
+    if (output["policyDocument"] !== undefined) {
+        contents.PolicyDocument = __expectString(output["policyDocument"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2ModifyVerifiedAccessGroupResult = (output, context) => {
+    const contents = {
+        VerifiedAccessGroup: undefined,
+    };
+    if (output["verifiedAccessGroup"] !== undefined) {
+        contents.VerifiedAccessGroup = deserializeAws_ec2VerifiedAccessGroup(output["verifiedAccessGroup"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2ModifyVerifiedAccessInstanceLoggingConfigurationResult = (output, context) => {
+    const contents = {
+        LoggingConfiguration: undefined,
+    };
+    if (output["loggingConfiguration"] !== undefined) {
+        contents.LoggingConfiguration = deserializeAws_ec2VerifiedAccessInstanceLoggingConfiguration(output["loggingConfiguration"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2ModifyVerifiedAccessInstanceResult = (output, context) => {
+    const contents = {
+        VerifiedAccessInstance: undefined,
+    };
+    if (output["verifiedAccessInstance"] !== undefined) {
+        contents.VerifiedAccessInstance = deserializeAws_ec2VerifiedAccessInstance(output["verifiedAccessInstance"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2ModifyVerifiedAccessTrustProviderResult = (output, context) => {
+    const contents = {
+        VerifiedAccessTrustProvider: undefined,
+    };
+    if (output["verifiedAccessTrustProvider"] !== undefined) {
+        contents.VerifiedAccessTrustProvider = deserializeAws_ec2VerifiedAccessTrustProvider(output["verifiedAccessTrustProvider"], context);
+    }
+    return contents;
+};
 const deserializeAws_ec2ModifyVolumeResult = (output, context) => {
     const contents = {
         VolumeModification: undefined,
@@ -56769,6 +59416,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 +59457,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 +59584,7 @@ const deserializeAws_ec2NetworkInsightsAnalysis = (output, context) => {
         NetworkInsightsAnalysisId: undefined,
         NetworkInsightsAnalysisArn: undefined,
         NetworkInsightsPathId: undefined,
+        AdditionalAccounts: undefined,
         FilterInArns: undefined,
         StartDate: undefined,
         Status: undefined,
@@ -56943,6 +59595,7 @@ const deserializeAws_ec2NetworkInsightsAnalysis = (output, context) => {
         ReturnPathComponents: undefined,
         Explanations: undefined,
         AlternatePathHints: undefined,
+        SuggestedAccounts: undefined,
         Tags: undefined,
     };
     if (output["networkInsightsAnalysisId"] !== undefined) {
@@ -56954,6 +59607,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 +59659,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 +59687,8 @@ const deserializeAws_ec2NetworkInsightsPath = (output, context) => {
         CreatedDate: undefined,
         Source: undefined,
         Destination: undefined,
+        SourceArn: undefined,
+        DestinationArn: undefined,
         SourceIp: undefined,
         DestinationIp: undefined,
         Protocol: undefined,
@@ -57043,6 +59710,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 +59913,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 +59939,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) => {
@@ -57387,6 +60064,39 @@ const deserializeAws_ec2OccurrenceDaySet = (output, context) => {
         return __strictParseInt32(entry);
     });
 };
+const deserializeAws_ec2OidcOptions = (output, context) => {
+    const contents = {
+        Issuer: undefined,
+        AuthorizationEndpoint: undefined,
+        TokenEndpoint: undefined,
+        UserInfoEndpoint: undefined,
+        ClientId: undefined,
+        ClientSecret: undefined,
+        Scope: undefined,
+    };
+    if (output["issuer"] !== undefined) {
+        contents.Issuer = __expectString(output["issuer"]);
+    }
+    if (output["authorizationEndpoint"] !== undefined) {
+        contents.AuthorizationEndpoint = __expectString(output["authorizationEndpoint"]);
+    }
+    if (output["tokenEndpoint"] !== undefined) {
+        contents.TokenEndpoint = __expectString(output["tokenEndpoint"]);
+    }
+    if (output["userInfoEndpoint"] !== undefined) {
+        contents.UserInfoEndpoint = __expectString(output["userInfoEndpoint"]);
+    }
+    if (output["clientId"] !== undefined) {
+        contents.ClientId = __expectString(output["clientId"]);
+    }
+    if (output["clientSecret"] !== undefined) {
+        contents.ClientSecret = __expectString(output["clientSecret"]);
+    }
+    if (output["scope"] !== undefined) {
+        contents.Scope = __expectString(output["scope"]);
+    }
+    return contents;
+};
 const deserializeAws_ec2OnDemandOptions = (output, context) => {
     const contents = {
         AllocationStrategy: undefined,
@@ -60035,6 +62745,13 @@ const deserializeAws_ec2SecurityGroupIdentifier = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2SecurityGroupIdList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return __expectString(entry);
+    });
+};
 const deserializeAws_ec2SecurityGroupIdStringList = (output, context) => {
     return (output || [])
         .filter((e) => e != null)
@@ -61652,6 +64369,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,
@@ -63872,6 +66621,451 @@ const deserializeAws_ec2VCpuInfo = (output, context) => {
     }
     return contents;
 };
+const deserializeAws_ec2VerifiedAccessEndpoint = (output, context) => {
+    const contents = {
+        VerifiedAccessInstanceId: undefined,
+        VerifiedAccessGroupId: undefined,
+        VerifiedAccessEndpointId: undefined,
+        ApplicationDomain: undefined,
+        EndpointType: undefined,
+        AttachmentType: undefined,
+        DomainCertificateArn: undefined,
+        EndpointDomain: undefined,
+        DeviceValidationDomain: undefined,
+        SecurityGroupIds: undefined,
+        LoadBalancerOptions: undefined,
+        NetworkInterfaceOptions: undefined,
+        Status: undefined,
+        Description: undefined,
+        CreationTime: undefined,
+        LastUpdatedTime: undefined,
+        DeletionTime: undefined,
+        Tags: undefined,
+    };
+    if (output["verifiedAccessInstanceId"] !== undefined) {
+        contents.VerifiedAccessInstanceId = __expectString(output["verifiedAccessInstanceId"]);
+    }
+    if (output["verifiedAccessGroupId"] !== undefined) {
+        contents.VerifiedAccessGroupId = __expectString(output["verifiedAccessGroupId"]);
+    }
+    if (output["verifiedAccessEndpointId"] !== undefined) {
+        contents.VerifiedAccessEndpointId = __expectString(output["verifiedAccessEndpointId"]);
+    }
+    if (output["applicationDomain"] !== undefined) {
+        contents.ApplicationDomain = __expectString(output["applicationDomain"]);
+    }
+    if (output["endpointType"] !== undefined) {
+        contents.EndpointType = __expectString(output["endpointType"]);
+    }
+    if (output["attachmentType"] !== undefined) {
+        contents.AttachmentType = __expectString(output["attachmentType"]);
+    }
+    if (output["domainCertificateArn"] !== undefined) {
+        contents.DomainCertificateArn = __expectString(output["domainCertificateArn"]);
+    }
+    if (output["endpointDomain"] !== undefined) {
+        contents.EndpointDomain = __expectString(output["endpointDomain"]);
+    }
+    if (output["deviceValidationDomain"] !== undefined) {
+        contents.DeviceValidationDomain = __expectString(output["deviceValidationDomain"]);
+    }
+    if (output.securityGroupIdSet === "") {
+        contents.SecurityGroupIds = [];
+    }
+    else if (output["securityGroupIdSet"] !== undefined && output["securityGroupIdSet"]["item"] !== undefined) {
+        contents.SecurityGroupIds = deserializeAws_ec2SecurityGroupIdList(__getArrayIfSingleItem(output["securityGroupIdSet"]["item"]), context);
+    }
+    if (output["loadBalancerOptions"] !== undefined) {
+        contents.LoadBalancerOptions = deserializeAws_ec2VerifiedAccessEndpointLoadBalancerOptions(output["loadBalancerOptions"], context);
+    }
+    if (output["networkInterfaceOptions"] !== undefined) {
+        contents.NetworkInterfaceOptions = deserializeAws_ec2VerifiedAccessEndpointEniOptions(output["networkInterfaceOptions"], context);
+    }
+    if (output["status"] !== undefined) {
+        contents.Status = deserializeAws_ec2VerifiedAccessEndpointStatus(output["status"], context);
+    }
+    if (output["description"] !== undefined) {
+        contents.Description = __expectString(output["description"]);
+    }
+    if (output["creationTime"] !== undefined) {
+        contents.CreationTime = __expectString(output["creationTime"]);
+    }
+    if (output["lastUpdatedTime"] !== undefined) {
+        contents.LastUpdatedTime = __expectString(output["lastUpdatedTime"]);
+    }
+    if (output["deletionTime"] !== undefined) {
+        contents.DeletionTime = __expectString(output["deletionTime"]);
+    }
+    if (output.tagSet === "") {
+        contents.Tags = [];
+    }
+    else if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
+        contents.Tags = deserializeAws_ec2TagList(__getArrayIfSingleItem(output["tagSet"]["item"]), context);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessEndpointEniOptions = (output, context) => {
+    const contents = {
+        NetworkInterfaceId: undefined,
+        Protocol: undefined,
+        Port: undefined,
+    };
+    if (output["networkInterfaceId"] !== undefined) {
+        contents.NetworkInterfaceId = __expectString(output["networkInterfaceId"]);
+    }
+    if (output["protocol"] !== undefined) {
+        contents.Protocol = __expectString(output["protocol"]);
+    }
+    if (output["port"] !== undefined) {
+        contents.Port = __strictParseInt32(output["port"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessEndpointList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2VerifiedAccessEndpoint(entry, context);
+    });
+};
+const deserializeAws_ec2VerifiedAccessEndpointLoadBalancerOptions = (output, context) => {
+    const contents = {
+        Protocol: undefined,
+        Port: undefined,
+        LoadBalancerArn: undefined,
+        SubnetIds: undefined,
+    };
+    if (output["protocol"] !== undefined) {
+        contents.Protocol = __expectString(output["protocol"]);
+    }
+    if (output["port"] !== undefined) {
+        contents.Port = __strictParseInt32(output["port"]);
+    }
+    if (output["loadBalancerArn"] !== undefined) {
+        contents.LoadBalancerArn = __expectString(output["loadBalancerArn"]);
+    }
+    if (output.subnetIdSet === "") {
+        contents.SubnetIds = [];
+    }
+    else if (output["subnetIdSet"] !== undefined && output["subnetIdSet"]["item"] !== undefined) {
+        contents.SubnetIds = deserializeAws_ec2VerifiedAccessEndpointSubnetIdList(__getArrayIfSingleItem(output["subnetIdSet"]["item"]), context);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessEndpointStatus = (output, context) => {
+    const contents = {
+        Code: undefined,
+        Message: undefined,
+    };
+    if (output["code"] !== undefined) {
+        contents.Code = __expectString(output["code"]);
+    }
+    if (output["message"] !== undefined) {
+        contents.Message = __expectString(output["message"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessEndpointSubnetIdList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return __expectString(entry);
+    });
+};
+const deserializeAws_ec2VerifiedAccessGroup = (output, context) => {
+    const contents = {
+        VerifiedAccessGroupId: undefined,
+        VerifiedAccessInstanceId: undefined,
+        Description: undefined,
+        Owner: undefined,
+        VerifiedAccessGroupArn: undefined,
+        CreationTime: undefined,
+        LastUpdatedTime: undefined,
+        DeletionTime: undefined,
+        Tags: undefined,
+    };
+    if (output["verifiedAccessGroupId"] !== undefined) {
+        contents.VerifiedAccessGroupId = __expectString(output["verifiedAccessGroupId"]);
+    }
+    if (output["verifiedAccessInstanceId"] !== undefined) {
+        contents.VerifiedAccessInstanceId = __expectString(output["verifiedAccessInstanceId"]);
+    }
+    if (output["description"] !== undefined) {
+        contents.Description = __expectString(output["description"]);
+    }
+    if (output["owner"] !== undefined) {
+        contents.Owner = __expectString(output["owner"]);
+    }
+    if (output["verifiedAccessGroupArn"] !== undefined) {
+        contents.VerifiedAccessGroupArn = __expectString(output["verifiedAccessGroupArn"]);
+    }
+    if (output["creationTime"] !== undefined) {
+        contents.CreationTime = __expectString(output["creationTime"]);
+    }
+    if (output["lastUpdatedTime"] !== undefined) {
+        contents.LastUpdatedTime = __expectString(output["lastUpdatedTime"]);
+    }
+    if (output["deletionTime"] !== undefined) {
+        contents.DeletionTime = __expectString(output["deletionTime"]);
+    }
+    if (output.tagSet === "") {
+        contents.Tags = [];
+    }
+    else if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
+        contents.Tags = deserializeAws_ec2TagList(__getArrayIfSingleItem(output["tagSet"]["item"]), context);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessGroupList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2VerifiedAccessGroup(entry, context);
+    });
+};
+const deserializeAws_ec2VerifiedAccessInstance = (output, context) => {
+    const contents = {
+        VerifiedAccessInstanceId: undefined,
+        Description: undefined,
+        VerifiedAccessTrustProviders: undefined,
+        CreationTime: undefined,
+        LastUpdatedTime: undefined,
+        Tags: undefined,
+    };
+    if (output["verifiedAccessInstanceId"] !== undefined) {
+        contents.VerifiedAccessInstanceId = __expectString(output["verifiedAccessInstanceId"]);
+    }
+    if (output["description"] !== undefined) {
+        contents.Description = __expectString(output["description"]);
+    }
+    if (output.verifiedAccessTrustProviderSet === "") {
+        contents.VerifiedAccessTrustProviders = [];
+    }
+    else if (output["verifiedAccessTrustProviderSet"] !== undefined &&
+        output["verifiedAccessTrustProviderSet"]["item"] !== undefined) {
+        contents.VerifiedAccessTrustProviders = deserializeAws_ec2VerifiedAccessTrustProviderCondensedList(__getArrayIfSingleItem(output["verifiedAccessTrustProviderSet"]["item"]), context);
+    }
+    if (output["creationTime"] !== undefined) {
+        contents.CreationTime = __expectString(output["creationTime"]);
+    }
+    if (output["lastUpdatedTime"] !== undefined) {
+        contents.LastUpdatedTime = __expectString(output["lastUpdatedTime"]);
+    }
+    if (output.tagSet === "") {
+        contents.Tags = [];
+    }
+    else if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
+        contents.Tags = deserializeAws_ec2TagList(__getArrayIfSingleItem(output["tagSet"]["item"]), context);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessInstanceList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2VerifiedAccessInstance(entry, context);
+    });
+};
+const deserializeAws_ec2VerifiedAccessInstanceLoggingConfiguration = (output, context) => {
+    const contents = {
+        VerifiedAccessInstanceId: undefined,
+        AccessLogs: undefined,
+    };
+    if (output["verifiedAccessInstanceId"] !== undefined) {
+        contents.VerifiedAccessInstanceId = __expectString(output["verifiedAccessInstanceId"]);
+    }
+    if (output["accessLogs"] !== undefined) {
+        contents.AccessLogs = deserializeAws_ec2VerifiedAccessLogs(output["accessLogs"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessInstanceLoggingConfigurationList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2VerifiedAccessInstanceLoggingConfiguration(entry, context);
+    });
+};
+const deserializeAws_ec2VerifiedAccessLogCloudWatchLogsDestination = (output, context) => {
+    const contents = {
+        Enabled: undefined,
+        DeliveryStatus: undefined,
+        LogGroup: undefined,
+    };
+    if (output["enabled"] !== undefined) {
+        contents.Enabled = __parseBoolean(output["enabled"]);
+    }
+    if (output["deliveryStatus"] !== undefined) {
+        contents.DeliveryStatus = deserializeAws_ec2VerifiedAccessLogDeliveryStatus(output["deliveryStatus"], context);
+    }
+    if (output["logGroup"] !== undefined) {
+        contents.LogGroup = __expectString(output["logGroup"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessLogDeliveryStatus = (output, context) => {
+    const contents = {
+        Code: undefined,
+        Message: undefined,
+    };
+    if (output["code"] !== undefined) {
+        contents.Code = __expectString(output["code"]);
+    }
+    if (output["message"] !== undefined) {
+        contents.Message = __expectString(output["message"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessLogKinesisDataFirehoseDestination = (output, context) => {
+    const contents = {
+        Enabled: undefined,
+        DeliveryStatus: undefined,
+        DeliveryStream: undefined,
+    };
+    if (output["enabled"] !== undefined) {
+        contents.Enabled = __parseBoolean(output["enabled"]);
+    }
+    if (output["deliveryStatus"] !== undefined) {
+        contents.DeliveryStatus = deserializeAws_ec2VerifiedAccessLogDeliveryStatus(output["deliveryStatus"], context);
+    }
+    if (output["deliveryStream"] !== undefined) {
+        contents.DeliveryStream = __expectString(output["deliveryStream"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessLogs = (output, context) => {
+    const contents = {
+        S3: undefined,
+        CloudWatchLogs: undefined,
+        KinesisDataFirehose: undefined,
+    };
+    if (output["s3"] !== undefined) {
+        contents.S3 = deserializeAws_ec2VerifiedAccessLogS3Destination(output["s3"], context);
+    }
+    if (output["cloudWatchLogs"] !== undefined) {
+        contents.CloudWatchLogs = deserializeAws_ec2VerifiedAccessLogCloudWatchLogsDestination(output["cloudWatchLogs"], context);
+    }
+    if (output["kinesisDataFirehose"] !== undefined) {
+        contents.KinesisDataFirehose = deserializeAws_ec2VerifiedAccessLogKinesisDataFirehoseDestination(output["kinesisDataFirehose"], context);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessLogS3Destination = (output, context) => {
+    const contents = {
+        Enabled: undefined,
+        DeliveryStatus: undefined,
+        BucketName: undefined,
+        Prefix: undefined,
+        BucketOwner: undefined,
+    };
+    if (output["enabled"] !== undefined) {
+        contents.Enabled = __parseBoolean(output["enabled"]);
+    }
+    if (output["deliveryStatus"] !== undefined) {
+        contents.DeliveryStatus = deserializeAws_ec2VerifiedAccessLogDeliveryStatus(output["deliveryStatus"], context);
+    }
+    if (output["bucketName"] !== undefined) {
+        contents.BucketName = __expectString(output["bucketName"]);
+    }
+    if (output["prefix"] !== undefined) {
+        contents.Prefix = __expectString(output["prefix"]);
+    }
+    if (output["bucketOwner"] !== undefined) {
+        contents.BucketOwner = __expectString(output["bucketOwner"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessTrustProvider = (output, context) => {
+    const contents = {
+        VerifiedAccessTrustProviderId: undefined,
+        Description: undefined,
+        TrustProviderType: undefined,
+        UserTrustProviderType: undefined,
+        DeviceTrustProviderType: undefined,
+        OidcOptions: undefined,
+        DeviceOptions: undefined,
+        PolicyReferenceName: undefined,
+        CreationTime: undefined,
+        LastUpdatedTime: undefined,
+        Tags: undefined,
+    };
+    if (output["verifiedAccessTrustProviderId"] !== undefined) {
+        contents.VerifiedAccessTrustProviderId = __expectString(output["verifiedAccessTrustProviderId"]);
+    }
+    if (output["description"] !== undefined) {
+        contents.Description = __expectString(output["description"]);
+    }
+    if (output["trustProviderType"] !== undefined) {
+        contents.TrustProviderType = __expectString(output["trustProviderType"]);
+    }
+    if (output["userTrustProviderType"] !== undefined) {
+        contents.UserTrustProviderType = __expectString(output["userTrustProviderType"]);
+    }
+    if (output["deviceTrustProviderType"] !== undefined) {
+        contents.DeviceTrustProviderType = __expectString(output["deviceTrustProviderType"]);
+    }
+    if (output["oidcOptions"] !== undefined) {
+        contents.OidcOptions = deserializeAws_ec2OidcOptions(output["oidcOptions"], context);
+    }
+    if (output["deviceOptions"] !== undefined) {
+        contents.DeviceOptions = deserializeAws_ec2DeviceOptions(output["deviceOptions"], context);
+    }
+    if (output["policyReferenceName"] !== undefined) {
+        contents.PolicyReferenceName = __expectString(output["policyReferenceName"]);
+    }
+    if (output["creationTime"] !== undefined) {
+        contents.CreationTime = __expectString(output["creationTime"]);
+    }
+    if (output["lastUpdatedTime"] !== undefined) {
+        contents.LastUpdatedTime = __expectString(output["lastUpdatedTime"]);
+    }
+    if (output.tagSet === "") {
+        contents.Tags = [];
+    }
+    else if (output["tagSet"] !== undefined && output["tagSet"]["item"] !== undefined) {
+        contents.Tags = deserializeAws_ec2TagList(__getArrayIfSingleItem(output["tagSet"]["item"]), context);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessTrustProviderCondensed = (output, context) => {
+    const contents = {
+        VerifiedAccessTrustProviderId: undefined,
+        Description: undefined,
+        TrustProviderType: undefined,
+        UserTrustProviderType: undefined,
+        DeviceTrustProviderType: undefined,
+    };
+    if (output["verifiedAccessTrustProviderId"] !== undefined) {
+        contents.VerifiedAccessTrustProviderId = __expectString(output["verifiedAccessTrustProviderId"]);
+    }
+    if (output["description"] !== undefined) {
+        contents.Description = __expectString(output["description"]);
+    }
+    if (output["trustProviderType"] !== undefined) {
+        contents.TrustProviderType = __expectString(output["trustProviderType"]);
+    }
+    if (output["userTrustProviderType"] !== undefined) {
+        contents.UserTrustProviderType = __expectString(output["userTrustProviderType"]);
+    }
+    if (output["deviceTrustProviderType"] !== undefined) {
+        contents.DeviceTrustProviderType = __expectString(output["deviceTrustProviderType"]);
+    }
+    return contents;
+};
+const deserializeAws_ec2VerifiedAccessTrustProviderCondensedList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2VerifiedAccessTrustProviderCondensed(entry, context);
+    });
+};
+const deserializeAws_ec2VerifiedAccessTrustProviderList = (output, context) => {
+    return (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return deserializeAws_ec2VerifiedAccessTrustProvider(entry, context);
+    });
+};
 const deserializeAws_ec2VgwTelemetry = (output, context) => {
     const contents = {
         AcceptedRouteCount: undefined,