@aws-sdk/client-ec2 3.219.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",
@@ -3855,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",
@@ -4095,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",
@@ -5055,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",
@@ -5679,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",
@@ -7431,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);
@@ -9768,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);
@@ -11556,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);
@@ -15210,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);
@@ -15744,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);
@@ -17886,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);
@@ -19269,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);
@@ -22271,6 +23207,25 @@ const serializeAws_ec2AttachNetworkInterfaceRequest = (input, context) => {
     }
     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) => {
     const entries = {};
     if (input.Device != null) {
@@ -25364,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) {
@@ -26547,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) {
@@ -30275,18 +31555,120 @@ const serializeAws_ec2DescribeTransitGatewayRouteTableAnnouncementsRequest = (in
     }
     return entries;
 };
-const serializeAws_ec2DescribeTransitGatewayRouteTablesRequest = (input, context) => {
+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);
+        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_ec2DescribeTrunkInterfaceAssociationsRequest = (input, context) => {
     const entries = {};
-    if (input.TransitGatewayRouteTableIds != null) {
-        const memberEntries = serializeAws_ec2TransitGatewayRouteTableIdStringList(input.TransitGatewayRouteTableIds, context);
-        if (input.TransitGatewayRouteTableIds?.length === 0) {
-            entries.TransitGatewayRouteTableIds = [];
+    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 = `TransitGatewayRouteTableIds.${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) {
@@ -30297,29 +31679,38 @@ 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;
+    if (input.MaxResults != null) {
+        entries["MaxResults"] = input.MaxResults;
     }
     return entries;
 };
-const serializeAws_ec2DescribeTransitGatewaysRequest = (input, context) => {
+const serializeAws_ec2DescribeVerifiedAccessEndpointsRequest = (input, context) => {
     const entries = {};
-    if (input.TransitGatewayIds != null) {
-        const memberEntries = serializeAws_ec2TransitGatewayIdStringList(input.TransitGatewayIds, context);
-        if (input.TransitGatewayIds?.length === 0) {
-            entries.TransitGatewayIds = [];
+    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 = `TransitGatewayIds.${key.substring(key.indexOf(".") + 1)}`;
+            const loc = `VerifiedAccessEndpointId.${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;
+    }
+    if (input.NextToken != null) {
+        entries["NextToken"] = input.NextToken;
+    }
     if (input.Filters != null) {
         const memberEntries = serializeAws_ec2FilterList(input.Filters, context);
         if (input.Filters?.length === 0) {
@@ -30330,29 +31721,65 @@ const serializeAws_ec2DescribeTransitGatewaysRequest = (input, context) => {
             entries[loc] = value;
         });
     }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2DescribeVerifiedAccessGroupsRequest = (input, context) => {
+    const entries = {};
+    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 = `VerifiedAccessGroupId.${key.substring(key.indexOf(".") + 1)}`;
+            entries[loc] = value;
+        });
+    }
+    if (input.VerifiedAccessInstanceId != null) {
+        entries["VerifiedAccessInstanceId"] = input.VerifiedAccessInstanceId;
+    }
     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_ec2DescribeTransitGatewayVpcAttachmentsRequest = (input, context) => {
+const serializeAws_ec2DescribeVerifiedAccessInstanceLoggingConfigurationsRequest = (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) {
@@ -30363,31 +31790,61 @@ const serializeAws_ec2DescribeTransitGatewayVpcAttachmentsRequest = (input, cont
             entries[loc] = value;
         });
     }
+    if (input.DryRun != null) {
+        entries["DryRun"] = input.DryRun;
+    }
+    return entries;
+};
+const serializeAws_ec2DescribeVerifiedAccessInstancesRequest = (input, context) => {
+    const entries = {};
+    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 = `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) {
+            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_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);
@@ -30399,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;
 };
@@ -30925,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) {
@@ -32862,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) {
@@ -36721,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) {
@@ -40419,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;
@@ -41843,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;
@@ -43308,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,
@@ -45682,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,
@@ -46443,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,
@@ -48625,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,
@@ -48931,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,
@@ -51692,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,
@@ -56851,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,
@@ -57943,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,
@@ -60591,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)
@@ -64460,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,