@aws-sdk/client-vpc-lattice 3.303.0

package/dist-es/protocols/Aws_restJson1.js

@@ -0,0 +1,4802 @@
+import { HttpRequest as __HttpRequest } from "@aws-sdk/protocol-http";
+import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, expectUnion as __expectUnion, map as __map, parseRfc3339DateTimeWithOffset as __parseRfc3339DateTimeWithOffset, resolvedPath as __resolvedPath, strictParseInt32 as __strictParseInt32, throwDefaultError, } from "@aws-sdk/smithy-client";
+import { v4 as generateIdempotencyToken } from "uuid";
+import { AccessDeniedException, ConflictException, HeaderMatchType, InternalServerException, Matcher, PathMatchType, ResourceNotFoundException, RuleAction, RuleMatch, ServiceQuotaExceededException, ThrottlingException, ValidationException, } from "../models/models_0";
+import { VPCLatticeServiceException as __BaseException } from "../models/VPCLatticeServiceException";
+export const serializeAws_restJson1BatchUpdateRuleCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.rules != null && { rules: serializeAws_restJson1RuleUpdateList(input.rules, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1CreateAccessLogSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/accesslogsubscriptions";
+    let body;
+    body = JSON.stringify({
+        clientToken: input.clientToken ?? generateIdempotencyToken(),
+        ...(input.destinationArn != null && { destinationArn: input.destinationArn }),
+        ...(input.resourceIdentifier != null && { resourceIdentifier: input.resourceIdentifier }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1CreateListenerCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services/{serviceIdentifier}/listeners";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        clientToken: input.clientToken ?? generateIdempotencyToken(),
+        ...(input.defaultAction != null && {
+            defaultAction: serializeAws_restJson1RuleAction(input.defaultAction, context),
+        }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.port != null && { port: input.port }),
+        ...(input.protocol != null && { protocol: input.protocol }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1CreateRuleCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.action != null && { action: serializeAws_restJson1RuleAction(input.action, context) }),
+        clientToken: input.clientToken ?? generateIdempotencyToken(),
+        ...(input.match != null && { match: serializeAws_restJson1RuleMatch(input.match, context) }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.priority != null && { priority: input.priority }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1CreateServiceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services";
+    let body;
+    body = JSON.stringify({
+        ...(input.authType != null && { authType: input.authType }),
+        ...(input.certificateArn != null && { certificateArn: input.certificateArn }),
+        clientToken: input.clientToken ?? generateIdempotencyToken(),
+        ...(input.customDomainName != null && { customDomainName: input.customDomainName }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1CreateServiceNetworkCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworks";
+    let body;
+    body = JSON.stringify({
+        ...(input.authType != null && { authType: input.authType }),
+        clientToken: input.clientToken ?? generateIdempotencyToken(),
+        ...(input.name != null && { name: input.name }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1CreateServiceNetworkServiceAssociationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworkserviceassociations";
+    let body;
+    body = JSON.stringify({
+        clientToken: input.clientToken ?? generateIdempotencyToken(),
+        ...(input.serviceIdentifier != null && { serviceIdentifier: input.serviceIdentifier }),
+        ...(input.serviceNetworkIdentifier != null && { serviceNetworkIdentifier: input.serviceNetworkIdentifier }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1CreateServiceNetworkVpcAssociationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworkvpcassociations";
+    let body;
+    body = JSON.stringify({
+        clientToken: input.clientToken ?? generateIdempotencyToken(),
+        ...(input.securityGroupIds != null && {
+            securityGroupIds: serializeAws_restJson1SecurityGroupList(input.securityGroupIds, context),
+        }),
+        ...(input.serviceNetworkIdentifier != null && { serviceNetworkIdentifier: input.serviceNetworkIdentifier }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.vpcIdentifier != null && { vpcIdentifier: input.vpcIdentifier }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1CreateTargetGroupCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetgroups";
+    let body;
+    body = JSON.stringify({
+        clientToken: input.clientToken ?? generateIdempotencyToken(),
+        ...(input.config != null && { config: serializeAws_restJson1TargetGroupConfig(input.config, context) }),
+        ...(input.name != null && { name: input.name }),
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+        ...(input.type != null && { type: input.type }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteAccessLogSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/accesslogsubscriptions/{accessLogSubscriptionIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteAuthPolicyCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/authpolicy/{resourceIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteListenerCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/services/{serviceIdentifier}/listeners/{listenerIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteResourcePolicyCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resourcepolicy/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteRuleCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteServiceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services/{serviceIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteServiceNetworkCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/servicenetworks/{serviceNetworkIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteServiceNetworkServiceAssociationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/servicenetworkserviceassociations/{serviceNetworkServiceAssociationIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkServiceAssociationIdentifier", () => input.serviceNetworkServiceAssociationIdentifier, "{serviceNetworkServiceAssociationIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteServiceNetworkVpcAssociationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeleteTargetGroupCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetgroups/{targetGroupIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1DeregisterTargetsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/targetgroups/{targetGroupIdentifier}/deregistertargets";
+    resolvedPath = __resolvedPath(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.targets != null && { targets: serializeAws_restJson1TargetList(input.targets, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetAccessLogSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/accesslogsubscriptions/{accessLogSubscriptionIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetAuthPolicyCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/authpolicy/{resourceIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetListenerCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/services/{serviceIdentifier}/listeners/{listenerIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetResourcePolicyCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resourcepolicy/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetRuleCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetServiceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services/{serviceIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetServiceNetworkCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/servicenetworks/{serviceNetworkIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetServiceNetworkServiceAssociationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/servicenetworkserviceassociations/{serviceNetworkServiceAssociationIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkServiceAssociationIdentifier", () => input.serviceNetworkServiceAssociationIdentifier, "{serviceNetworkServiceAssociationIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetServiceNetworkVpcAssociationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1GetTargetGroupCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetgroups/{targetGroupIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1ListAccessLogSubscriptionsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/accesslogsubscriptions";
+    const query = map({
+        resourceIdentifier: [, __expectNonNull(input.resourceIdentifier, `resourceIdentifier`)],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1ListListenersCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services/{serviceIdentifier}/listeners";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    const query = map({
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1ListRulesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
+    const query = map({
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1ListServiceNetworksCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworks";
+    const query = map({
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1ListServiceNetworkServiceAssociationsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworkserviceassociations";
+    const query = map({
+        serviceNetworkIdentifier: [, input.serviceNetworkIdentifier],
+        serviceIdentifier: [, input.serviceIdentifier],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1ListServiceNetworkVpcAssociationsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/servicenetworkvpcassociations";
+    const query = map({
+        serviceNetworkIdentifier: [, input.serviceNetworkIdentifier],
+        vpcIdentifier: [, input.vpcIdentifier],
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1ListServicesCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services";
+    const query = map({
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1ListTagsForResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1ListTargetGroupsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    const resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetgroups";
+    const query = map({
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+        vpcIdentifier: [, input.vpcIdentifier],
+        targetGroupType: [, input.targetGroupType],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "GET",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1ListTargetsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/targetgroups/{targetGroupIdentifier}/listtargets";
+    resolvedPath = __resolvedPath(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
+    const query = map({
+        maxResults: [() => input.maxResults !== void 0, () => input.maxResults.toString()],
+        nextToken: [, input.nextToken],
+    });
+    let body;
+    body = JSON.stringify({
+        ...(input.targets != null && { targets: serializeAws_restJson1TargetList(input.targets, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1PutAuthPolicyCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/authpolicy/{resourceIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceIdentifier", () => input.resourceIdentifier, "{resourceIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.policy != null && { policy: input.policy }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1PutResourcePolicyCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/resourcepolicy/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.policy != null && { policy: input.policy }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PUT",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1RegisterTargetsCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/targetgroups/{targetGroupIdentifier}/registertargets";
+    resolvedPath = __resolvedPath(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.targets != null && { targets: serializeAws_restJson1TargetList(input.targets, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1TagResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.tags != null && { tags: serializeAws_restJson1TagMap(input.tags, context) }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UntagResourceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {};
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/tags/{resourceArn}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "resourceArn", () => input.resourceArn, "{resourceArn}", false);
+    const query = map({
+        tagKeys: [
+            __expectNonNull(input.tagKeys, `tagKeys`) != null,
+            () => (input.tagKeys || []).map((_entry) => _entry),
+        ],
+    });
+    let body;
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "DELETE",
+        headers,
+        path: resolvedPath,
+        query,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateAccessLogSubscriptionCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/accesslogsubscriptions/{accessLogSubscriptionIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "accessLogSubscriptionIdentifier", () => input.accessLogSubscriptionIdentifier, "{accessLogSubscriptionIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.destinationArn != null && { destinationArn: input.destinationArn }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateListenerCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/services/{serviceIdentifier}/listeners/{listenerIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.defaultAction != null && {
+            defaultAction: serializeAws_restJson1RuleAction(input.defaultAction, context),
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateRuleCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "listenerIdentifier", () => input.listenerIdentifier, "{listenerIdentifier}", false);
+    resolvedPath = __resolvedPath(resolvedPath, input, "ruleIdentifier", () => input.ruleIdentifier, "{ruleIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.action != null && { action: serializeAws_restJson1RuleAction(input.action, context) }),
+        ...(input.match != null && { match: serializeAws_restJson1RuleMatch(input.match, context) }),
+        ...(input.priority != null && { priority: input.priority }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateServiceCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/services/{serviceIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceIdentifier", () => input.serviceIdentifier, "{serviceIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.authType != null && { authType: input.authType }),
+        ...(input.certificateArn != null && { certificateArn: input.certificateArn }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateServiceNetworkCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/servicenetworks/{serviceNetworkIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkIdentifier", () => input.serviceNetworkIdentifier, "{serviceNetworkIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.authType != null && { authType: input.authType }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateServiceNetworkVpcAssociationCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` +
+        "/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "serviceNetworkVpcAssociationIdentifier", () => input.serviceNetworkVpcAssociationIdentifier, "{serviceNetworkVpcAssociationIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.securityGroupIds != null && {
+            securityGroupIds: serializeAws_restJson1SecurityGroupList(input.securityGroupIds, context),
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const serializeAws_restJson1UpdateTargetGroupCommand = async (input, context) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const headers = {
+        "content-type": "application/json",
+    };
+    let resolvedPath = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + "/targetgroups/{targetGroupIdentifier}";
+    resolvedPath = __resolvedPath(resolvedPath, input, "targetGroupIdentifier", () => input.targetGroupIdentifier, "{targetGroupIdentifier}", false);
+    let body;
+    body = JSON.stringify({
+        ...(input.healthCheck != null && {
+            healthCheck: serializeAws_restJson1HealthCheckConfig(input.healthCheck, context),
+        }),
+    });
+    return new __HttpRequest({
+        protocol,
+        hostname,
+        port,
+        method: "PATCH",
+        headers,
+        path: resolvedPath,
+        body,
+    });
+};
+export const deserializeAws_restJson1BatchUpdateRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1BatchUpdateRuleCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.successful != null) {
+        contents.successful = deserializeAws_restJson1RuleUpdateSuccessList(data.successful, context);
+    }
+    if (data.unsuccessful != null) {
+        contents.unsuccessful = deserializeAws_restJson1RuleUpdateFailureList(data.unsuccessful, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1BatchUpdateRuleCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateAccessLogSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateAccessLogSubscriptionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.destinationArn != null) {
+        contents.destinationArn = __expectString(data.destinationArn);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.resourceArn != null) {
+        contents.resourceArn = __expectString(data.resourceArn);
+    }
+    if (data.resourceId != null) {
+        contents.resourceId = __expectString(data.resourceId);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateAccessLogSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateListenerCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateListenerCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.defaultAction != null) {
+        contents.defaultAction = deserializeAws_restJson1RuleAction(__expectUnion(data.defaultAction), context);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.port != null) {
+        contents.port = __expectInt32(data.port);
+    }
+    if (data.protocol != null) {
+        contents.protocol = __expectString(data.protocol);
+    }
+    if (data.serviceArn != null) {
+        contents.serviceArn = __expectString(data.serviceArn);
+    }
+    if (data.serviceId != null) {
+        contents.serviceId = __expectString(data.serviceId);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateListenerCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.vpclattice#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateRuleCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateRuleCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.action != null) {
+        contents.action = deserializeAws_restJson1RuleAction(__expectUnion(data.action), context);
+    }
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.match != null) {
+        contents.match = deserializeAws_restJson1RuleMatch(__expectUnion(data.match), context);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.priority != null) {
+        contents.priority = __expectInt32(data.priority);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateRuleCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.vpclattice#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateServiceCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateServiceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.authType != null) {
+        contents.authType = __expectString(data.authType);
+    }
+    if (data.certificateArn != null) {
+        contents.certificateArn = __expectString(data.certificateArn);
+    }
+    if (data.customDomainName != null) {
+        contents.customDomainName = __expectString(data.customDomainName);
+    }
+    if (data.dnsEntry != null) {
+        contents.dnsEntry = deserializeAws_restJson1DnsEntry(data.dnsEntry, context);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateServiceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.vpclattice#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateServiceNetworkCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateServiceNetworkCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.authType != null) {
+        contents.authType = __expectString(data.authType);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateServiceNetworkCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.vpclattice#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateServiceNetworkServiceAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateServiceNetworkServiceAssociationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.createdBy != null) {
+        contents.createdBy = __expectString(data.createdBy);
+    }
+    if (data.customDomainName != null) {
+        contents.customDomainName = __expectString(data.customDomainName);
+    }
+    if (data.dnsEntry != null) {
+        contents.dnsEntry = deserializeAws_restJson1DnsEntry(data.dnsEntry, context);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateServiceNetworkServiceAssociationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.vpclattice#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateServiceNetworkVpcAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateServiceNetworkVpcAssociationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.createdBy != null) {
+        contents.createdBy = __expectString(data.createdBy);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.securityGroupIds != null) {
+        contents.securityGroupIds = deserializeAws_restJson1SecurityGroupList(data.securityGroupIds, context);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateServiceNetworkVpcAssociationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.vpclattice#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1CreateTargetGroupCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return deserializeAws_restJson1CreateTargetGroupCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.config != null) {
+        contents.config = deserializeAws_restJson1TargetGroupConfig(data.config, context);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    if (data.type != null) {
+        contents.type = __expectString(data.type);
+    }
+    return contents;
+};
+const deserializeAws_restJson1CreateTargetGroupCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.vpclattice#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteAccessLogSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteAccessLogSubscriptionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteAccessLogSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteAuthPolicyCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteAuthPolicyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteAuthPolicyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteListenerCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteListenerCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteListenerCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteResourcePolicyCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteResourcePolicyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteResourcePolicyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteRuleCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteRuleCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteRuleCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteServiceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteServiceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1DeleteServiceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteServiceNetworkCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteServiceNetworkCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1DeleteServiceNetworkCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteServiceNetworkServiceAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteServiceNetworkServiceAssociationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1DeleteServiceNetworkServiceAssociationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteServiceNetworkVpcAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteServiceNetworkVpcAssociationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1DeleteServiceNetworkVpcAssociationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeleteTargetGroupCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeleteTargetGroupCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1DeleteTargetGroupCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1DeregisterTargetsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1DeregisterTargetsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.successful != null) {
+        contents.successful = deserializeAws_restJson1TargetList(data.successful, context);
+    }
+    if (data.unsuccessful != null) {
+        contents.unsuccessful = deserializeAws_restJson1TargetFailureList(data.unsuccessful, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1DeregisterTargetsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetAccessLogSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetAccessLogSubscriptionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.createdAt != null) {
+        contents.createdAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdAt));
+    }
+    if (data.destinationArn != null) {
+        contents.destinationArn = __expectString(data.destinationArn);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.lastUpdatedAt != null) {
+        contents.lastUpdatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.lastUpdatedAt));
+    }
+    if (data.resourceArn != null) {
+        contents.resourceArn = __expectString(data.resourceArn);
+    }
+    if (data.resourceId != null) {
+        contents.resourceId = __expectString(data.resourceId);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetAccessLogSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetAuthPolicyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetAuthPolicyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.createdAt != null) {
+        contents.createdAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdAt));
+    }
+    if (data.lastUpdatedAt != null) {
+        contents.lastUpdatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.lastUpdatedAt));
+    }
+    if (data.policy != null) {
+        contents.policy = __expectString(data.policy);
+    }
+    if (data.state != null) {
+        contents.state = __expectString(data.state);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetAuthPolicyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetListenerCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetListenerCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.createdAt != null) {
+        contents.createdAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdAt));
+    }
+    if (data.defaultAction != null) {
+        contents.defaultAction = deserializeAws_restJson1RuleAction(__expectUnion(data.defaultAction), context);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.lastUpdatedAt != null) {
+        contents.lastUpdatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.lastUpdatedAt));
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.port != null) {
+        contents.port = __expectInt32(data.port);
+    }
+    if (data.protocol != null) {
+        contents.protocol = __expectString(data.protocol);
+    }
+    if (data.serviceArn != null) {
+        contents.serviceArn = __expectString(data.serviceArn);
+    }
+    if (data.serviceId != null) {
+        contents.serviceId = __expectString(data.serviceId);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetListenerCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetResourcePolicyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetResourcePolicyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.policy != null) {
+        contents.policy = __expectString(data.policy);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetResourcePolicyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetRuleCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.action != null) {
+        contents.action = deserializeAws_restJson1RuleAction(__expectUnion(data.action), context);
+    }
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.createdAt != null) {
+        contents.createdAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdAt));
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.isDefault != null) {
+        contents.isDefault = __expectBoolean(data.isDefault);
+    }
+    if (data.lastUpdatedAt != null) {
+        contents.lastUpdatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.lastUpdatedAt));
+    }
+    if (data.match != null) {
+        contents.match = deserializeAws_restJson1RuleMatch(__expectUnion(data.match), context);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.priority != null) {
+        contents.priority = __expectInt32(data.priority);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetRuleCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetServiceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetServiceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.authType != null) {
+        contents.authType = __expectString(data.authType);
+    }
+    if (data.certificateArn != null) {
+        contents.certificateArn = __expectString(data.certificateArn);
+    }
+    if (data.createdAt != null) {
+        contents.createdAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdAt));
+    }
+    if (data.customDomainName != null) {
+        contents.customDomainName = __expectString(data.customDomainName);
+    }
+    if (data.dnsEntry != null) {
+        contents.dnsEntry = deserializeAws_restJson1DnsEntry(data.dnsEntry, context);
+    }
+    if (data.failureCode != null) {
+        contents.failureCode = __expectString(data.failureCode);
+    }
+    if (data.failureMessage != null) {
+        contents.failureMessage = __expectString(data.failureMessage);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.lastUpdatedAt != null) {
+        contents.lastUpdatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.lastUpdatedAt));
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetServiceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetServiceNetworkCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetServiceNetworkCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.authType != null) {
+        contents.authType = __expectString(data.authType);
+    }
+    if (data.createdAt != null) {
+        contents.createdAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdAt));
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.lastUpdatedAt != null) {
+        contents.lastUpdatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.lastUpdatedAt));
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.numberOfAssociatedServices != null) {
+        contents.numberOfAssociatedServices = __expectLong(data.numberOfAssociatedServices);
+    }
+    if (data.numberOfAssociatedVPCs != null) {
+        contents.numberOfAssociatedVPCs = __expectLong(data.numberOfAssociatedVPCs);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetServiceNetworkCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetServiceNetworkServiceAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetServiceNetworkServiceAssociationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.createdAt != null) {
+        contents.createdAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdAt));
+    }
+    if (data.createdBy != null) {
+        contents.createdBy = __expectString(data.createdBy);
+    }
+    if (data.customDomainName != null) {
+        contents.customDomainName = __expectString(data.customDomainName);
+    }
+    if (data.dnsEntry != null) {
+        contents.dnsEntry = deserializeAws_restJson1DnsEntry(data.dnsEntry, context);
+    }
+    if (data.failureCode != null) {
+        contents.failureCode = __expectString(data.failureCode);
+    }
+    if (data.failureMessage != null) {
+        contents.failureMessage = __expectString(data.failureMessage);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.serviceArn != null) {
+        contents.serviceArn = __expectString(data.serviceArn);
+    }
+    if (data.serviceId != null) {
+        contents.serviceId = __expectString(data.serviceId);
+    }
+    if (data.serviceName != null) {
+        contents.serviceName = __expectString(data.serviceName);
+    }
+    if (data.serviceNetworkArn != null) {
+        contents.serviceNetworkArn = __expectString(data.serviceNetworkArn);
+    }
+    if (data.serviceNetworkId != null) {
+        contents.serviceNetworkId = __expectString(data.serviceNetworkId);
+    }
+    if (data.serviceNetworkName != null) {
+        contents.serviceNetworkName = __expectString(data.serviceNetworkName);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetServiceNetworkServiceAssociationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetServiceNetworkVpcAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetServiceNetworkVpcAssociationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.createdAt != null) {
+        contents.createdAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdAt));
+    }
+    if (data.createdBy != null) {
+        contents.createdBy = __expectString(data.createdBy);
+    }
+    if (data.failureCode != null) {
+        contents.failureCode = __expectString(data.failureCode);
+    }
+    if (data.failureMessage != null) {
+        contents.failureMessage = __expectString(data.failureMessage);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.lastUpdatedAt != null) {
+        contents.lastUpdatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.lastUpdatedAt));
+    }
+    if (data.securityGroupIds != null) {
+        contents.securityGroupIds = deserializeAws_restJson1SecurityGroupList(data.securityGroupIds, context);
+    }
+    if (data.serviceNetworkArn != null) {
+        contents.serviceNetworkArn = __expectString(data.serviceNetworkArn);
+    }
+    if (data.serviceNetworkId != null) {
+        contents.serviceNetworkId = __expectString(data.serviceNetworkId);
+    }
+    if (data.serviceNetworkName != null) {
+        contents.serviceNetworkName = __expectString(data.serviceNetworkName);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    if (data.vpcId != null) {
+        contents.vpcId = __expectString(data.vpcId);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetServiceNetworkVpcAssociationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1GetTargetGroupCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1GetTargetGroupCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.config != null) {
+        contents.config = deserializeAws_restJson1TargetGroupConfig(data.config, context);
+    }
+    if (data.createdAt != null) {
+        contents.createdAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.createdAt));
+    }
+    if (data.failureCode != null) {
+        contents.failureCode = __expectString(data.failureCode);
+    }
+    if (data.failureMessage != null) {
+        contents.failureMessage = __expectString(data.failureMessage);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.lastUpdatedAt != null) {
+        contents.lastUpdatedAt = __expectNonNull(__parseRfc3339DateTimeWithOffset(data.lastUpdatedAt));
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.serviceArns != null) {
+        contents.serviceArns = deserializeAws_restJson1ServiceArnList(data.serviceArns, context);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    if (data.type != null) {
+        contents.type = __expectString(data.type);
+    }
+    return contents;
+};
+const deserializeAws_restJson1GetTargetGroupCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListAccessLogSubscriptionsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListAccessLogSubscriptionsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1AccessLogSubscriptionList(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListAccessLogSubscriptionsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListListenersCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListListenersCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1ListenerSummaryList(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListListenersCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListRulesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListRulesCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1RuleSummaryList(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListRulesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListServiceNetworksCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListServiceNetworksCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1ServiceNetworkList(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListServiceNetworksCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListServiceNetworkServiceAssociationsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListServiceNetworkServiceAssociationsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1ServiceNetworkServiceAssociationList(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListServiceNetworkServiceAssociationsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListServiceNetworkVpcAssociationsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListServiceNetworkVpcAssociationsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1ServiceNetworkVpcAssociationList(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListServiceNetworkVpcAssociationsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListServicesCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListServicesCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1ServiceList(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListServicesCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListTagsForResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListTagsForResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.tags != null) {
+        contents.tags = deserializeAws_restJson1TagMap(data.tags, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListTagsForResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListTargetGroupsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListTargetGroupsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1TargetGroupList(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListTargetGroupsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1ListTargetsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1ListTargetsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.items != null) {
+        contents.items = deserializeAws_restJson1TargetSummaryList(data.items, context);
+    }
+    if (data.nextToken != null) {
+        contents.nextToken = __expectString(data.nextToken);
+    }
+    return contents;
+};
+const deserializeAws_restJson1ListTargetsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1PutAuthPolicyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1PutAuthPolicyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.policy != null) {
+        contents.policy = __expectString(data.policy);
+    }
+    if (data.state != null) {
+        contents.state = __expectString(data.state);
+    }
+    return contents;
+};
+const deserializeAws_restJson1PutAuthPolicyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1PutResourcePolicyCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1PutResourcePolicyCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1PutResourcePolicyCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1RegisterTargetsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1RegisterTargetsCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.successful != null) {
+        contents.successful = deserializeAws_restJson1TargetList(data.successful, context);
+    }
+    if (data.unsuccessful != null) {
+        contents.unsuccessful = deserializeAws_restJson1TargetFailureList(data.unsuccessful, context);
+    }
+    return contents;
+};
+const deserializeAws_restJson1RegisterTargetsCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.vpclattice#ServiceQuotaExceededException":
+            throw await deserializeAws_restJson1ServiceQuotaExceededExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1TagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1TagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1TagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UntagResourceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UntagResourceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+const deserializeAws_restJson1UntagResourceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UpdateAccessLogSubscriptionCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateAccessLogSubscriptionCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.destinationArn != null) {
+        contents.destinationArn = __expectString(data.destinationArn);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.resourceArn != null) {
+        contents.resourceArn = __expectString(data.resourceArn);
+    }
+    if (data.resourceId != null) {
+        contents.resourceId = __expectString(data.resourceId);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UpdateAccessLogSubscriptionCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UpdateListenerCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateListenerCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.defaultAction != null) {
+        contents.defaultAction = deserializeAws_restJson1RuleAction(__expectUnion(data.defaultAction), context);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.port != null) {
+        contents.port = __expectInt32(data.port);
+    }
+    if (data.protocol != null) {
+        contents.protocol = __expectString(data.protocol);
+    }
+    if (data.serviceArn != null) {
+        contents.serviceArn = __expectString(data.serviceArn);
+    }
+    if (data.serviceId != null) {
+        contents.serviceId = __expectString(data.serviceId);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UpdateListenerCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UpdateRuleCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateRuleCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.action != null) {
+        contents.action = deserializeAws_restJson1RuleAction(__expectUnion(data.action), context);
+    }
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.isDefault != null) {
+        contents.isDefault = __expectBoolean(data.isDefault);
+    }
+    if (data.match != null) {
+        contents.match = deserializeAws_restJson1RuleMatch(__expectUnion(data.match), context);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.priority != null) {
+        contents.priority = __expectInt32(data.priority);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UpdateRuleCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UpdateServiceCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateServiceCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.authType != null) {
+        contents.authType = __expectString(data.authType);
+    }
+    if (data.certificateArn != null) {
+        contents.certificateArn = __expectString(data.certificateArn);
+    }
+    if (data.customDomainName != null) {
+        contents.customDomainName = __expectString(data.customDomainName);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UpdateServiceCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UpdateServiceNetworkCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateServiceNetworkCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.authType != null) {
+        contents.authType = __expectString(data.authType);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UpdateServiceNetworkCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UpdateServiceNetworkVpcAssociationCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateServiceNetworkVpcAssociationCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.createdBy != null) {
+        contents.createdBy = __expectString(data.createdBy);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.securityGroupIds != null) {
+        contents.securityGroupIds = deserializeAws_restJson1SecurityGroupList(data.securityGroupIds, context);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UpdateServiceNetworkVpcAssociationCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "AccessDeniedException":
+        case "com.amazonaws.vpclattice#AccessDeniedException":
+            throw await deserializeAws_restJson1AccessDeniedExceptionResponse(parsedOutput, context);
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+export const deserializeAws_restJson1UpdateTargetGroupCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return deserializeAws_restJson1UpdateTargetGroupCommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
+    if (data.arn != null) {
+        contents.arn = __expectString(data.arn);
+    }
+    if (data.config != null) {
+        contents.config = deserializeAws_restJson1TargetGroupConfig(data.config, context);
+    }
+    if (data.id != null) {
+        contents.id = __expectString(data.id);
+    }
+    if (data.name != null) {
+        contents.name = __expectString(data.name);
+    }
+    if (data.status != null) {
+        contents.status = __expectString(data.status);
+    }
+    if (data.type != null) {
+        contents.type = __expectString(data.type);
+    }
+    return contents;
+};
+const deserializeAws_restJson1UpdateTargetGroupCommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await parseErrorBody(output.body, context),
+    };
+    const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ConflictException":
+        case "com.amazonaws.vpclattice#ConflictException":
+            throw await deserializeAws_restJson1ConflictExceptionResponse(parsedOutput, context);
+        case "InternalServerException":
+        case "com.amazonaws.vpclattice#InternalServerException":
+            throw await deserializeAws_restJson1InternalServerExceptionResponse(parsedOutput, context);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.vpclattice#ResourceNotFoundException":
+            throw await deserializeAws_restJson1ResourceNotFoundExceptionResponse(parsedOutput, context);
+        case "ThrottlingException":
+        case "com.amazonaws.vpclattice#ThrottlingException":
+            throw await deserializeAws_restJson1ThrottlingExceptionResponse(parsedOutput, context);
+        case "ValidationException":
+        case "com.amazonaws.vpclattice#ValidationException":
+            throw await deserializeAws_restJson1ValidationExceptionResponse(parsedOutput, context);
+        default:
+            const parsedBody = parsedOutput.body;
+            throwDefaultError({
+                output,
+                parsedBody,
+                exceptionCtor: __BaseException,
+                errorCode,
+            });
+    }
+};
+const map = __map;
+const deserializeAws_restJson1AccessDeniedExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    const exception = new AccessDeniedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ConflictExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    if (data.resourceId != null) {
+        contents.resourceId = __expectString(data.resourceId);
+    }
+    if (data.resourceType != null) {
+        contents.resourceType = __expectString(data.resourceType);
+    }
+    const exception = new ConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1InternalServerExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({
+        retryAfterSeconds: [
+            () => void 0 !== parsedOutput.headers["retry-after"],
+            () => __strictParseInt32(parsedOutput.headers["retry-after"]),
+        ],
+    });
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    const exception = new InternalServerException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ResourceNotFoundExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    if (data.resourceId != null) {
+        contents.resourceId = __expectString(data.resourceId);
+    }
+    if (data.resourceType != null) {
+        contents.resourceType = __expectString(data.resourceType);
+    }
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ServiceQuotaExceededExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    if (data.quotaCode != null) {
+        contents.quotaCode = __expectString(data.quotaCode);
+    }
+    if (data.resourceId != null) {
+        contents.resourceId = __expectString(data.resourceId);
+    }
+    if (data.resourceType != null) {
+        contents.resourceType = __expectString(data.resourceType);
+    }
+    if (data.serviceCode != null) {
+        contents.serviceCode = __expectString(data.serviceCode);
+    }
+    const exception = new ServiceQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ThrottlingExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({
+        retryAfterSeconds: [
+            () => void 0 !== parsedOutput.headers["retry-after"],
+            () => __strictParseInt32(parsedOutput.headers["retry-after"]),
+        ],
+    });
+    const data = parsedOutput.body;
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    if (data.quotaCode != null) {
+        contents.quotaCode = __expectString(data.quotaCode);
+    }
+    if (data.serviceCode != null) {
+        contents.serviceCode = __expectString(data.serviceCode);
+    }
+    const exception = new ThrottlingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const deserializeAws_restJson1ValidationExceptionResponse = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    if (data.fieldList != null) {
+        contents.fieldList = deserializeAws_restJson1ValidationExceptionFieldList(data.fieldList, context);
+    }
+    if (data.message != null) {
+        contents.message = __expectString(data.message);
+    }
+    if (data.reason != null) {
+        contents.reason = __expectString(data.reason);
+    }
+    const exception = new ValidationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents,
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const serializeAws_restJson1FixedResponseAction = (input, context) => {
+    return {
+        ...(input.statusCode != null && { statusCode: input.statusCode }),
+    };
+};
+const serializeAws_restJson1ForwardAction = (input, context) => {
+    return {
+        ...(input.targetGroups != null && {
+            targetGroups: serializeAws_restJson1WeightedTargetGroupList(input.targetGroups, context),
+        }),
+    };
+};
+const serializeAws_restJson1HeaderMatch = (input, context) => {
+    return {
+        ...(input.caseSensitive != null && { caseSensitive: input.caseSensitive }),
+        ...(input.match != null && { match: serializeAws_restJson1HeaderMatchType(input.match, context) }),
+        ...(input.name != null && { name: input.name }),
+    };
+};
+const serializeAws_restJson1HeaderMatchList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1HeaderMatch(entry, context);
+    });
+};
+const serializeAws_restJson1HeaderMatchType = (input, context) => {
+    return HeaderMatchType.visit(input, {
+        contains: (value) => ({ contains: value }),
+        exact: (value) => ({ exact: value }),
+        prefix: (value) => ({ prefix: value }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1HealthCheckConfig = (input, context) => {
+    return {
+        ...(input.enabled != null && { enabled: input.enabled }),
+        ...(input.healthCheckIntervalSeconds != null && { healthCheckIntervalSeconds: input.healthCheckIntervalSeconds }),
+        ...(input.healthCheckTimeoutSeconds != null && { healthCheckTimeoutSeconds: input.healthCheckTimeoutSeconds }),
+        ...(input.healthyThresholdCount != null && { healthyThresholdCount: input.healthyThresholdCount }),
+        ...(input.matcher != null && { matcher: serializeAws_restJson1Matcher(input.matcher, context) }),
+        ...(input.path != null && { path: input.path }),
+        ...(input.port != null && { port: input.port }),
+        ...(input.protocol != null && { protocol: input.protocol }),
+        ...(input.protocolVersion != null && { protocolVersion: input.protocolVersion }),
+        ...(input.unhealthyThresholdCount != null && { unhealthyThresholdCount: input.unhealthyThresholdCount }),
+    };
+};
+const serializeAws_restJson1HttpMatch = (input, context) => {
+    return {
+        ...(input.headerMatches != null && {
+            headerMatches: serializeAws_restJson1HeaderMatchList(input.headerMatches, context),
+        }),
+        ...(input.method != null && { method: input.method }),
+        ...(input.pathMatch != null && { pathMatch: serializeAws_restJson1PathMatch(input.pathMatch, context) }),
+    };
+};
+const serializeAws_restJson1Matcher = (input, context) => {
+    return Matcher.visit(input, {
+        httpCode: (value) => ({ httpCode: value }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1PathMatch = (input, context) => {
+    return {
+        ...(input.caseSensitive != null && { caseSensitive: input.caseSensitive }),
+        ...(input.match != null && { match: serializeAws_restJson1PathMatchType(input.match, context) }),
+    };
+};
+const serializeAws_restJson1PathMatchType = (input, context) => {
+    return PathMatchType.visit(input, {
+        exact: (value) => ({ exact: value }),
+        prefix: (value) => ({ prefix: value }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1RuleAction = (input, context) => {
+    return RuleAction.visit(input, {
+        fixedResponse: (value) => ({ fixedResponse: serializeAws_restJson1FixedResponseAction(value, context) }),
+        forward: (value) => ({ forward: serializeAws_restJson1ForwardAction(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1RuleMatch = (input, context) => {
+    return RuleMatch.visit(input, {
+        httpMatch: (value) => ({ httpMatch: serializeAws_restJson1HttpMatch(value, context) }),
+        _: (name, value) => ({ name: value }),
+    });
+};
+const serializeAws_restJson1RuleUpdate = (input, context) => {
+    return {
+        ...(input.action != null && { action: serializeAws_restJson1RuleAction(input.action, context) }),
+        ...(input.match != null && { match: serializeAws_restJson1RuleMatch(input.match, context) }),
+        ...(input.priority != null && { priority: input.priority }),
+        ...(input.ruleIdentifier != null && { ruleIdentifier: input.ruleIdentifier }),
+    };
+};
+const serializeAws_restJson1RuleUpdateList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1RuleUpdate(entry, context);
+    });
+};
+const serializeAws_restJson1SecurityGroupList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return entry;
+    });
+};
+const serializeAws_restJson1TagMap = (input, context) => {
+    return Object.entries(input).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = value;
+        return acc;
+    }, {});
+};
+const serializeAws_restJson1Target = (input, context) => {
+    return {
+        ...(input.id != null && { id: input.id }),
+        ...(input.port != null && { port: input.port }),
+    };
+};
+const serializeAws_restJson1TargetGroupConfig = (input, context) => {
+    return {
+        ...(input.healthCheck != null && {
+            healthCheck: serializeAws_restJson1HealthCheckConfig(input.healthCheck, context),
+        }),
+        ...(input.ipAddressType != null && { ipAddressType: input.ipAddressType }),
+        ...(input.port != null && { port: input.port }),
+        ...(input.protocol != null && { protocol: input.protocol }),
+        ...(input.protocolVersion != null && { protocolVersion: input.protocolVersion }),
+        ...(input.vpcIdentifier != null && { vpcIdentifier: input.vpcIdentifier }),
+    };
+};
+const serializeAws_restJson1TargetList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1Target(entry, context);
+    });
+};
+const serializeAws_restJson1WeightedTargetGroup = (input, context) => {
+    return {
+        ...(input.targetGroupIdentifier != null && { targetGroupIdentifier: input.targetGroupIdentifier }),
+        ...(input.weight != null && { weight: input.weight }),
+    };
+};
+const serializeAws_restJson1WeightedTargetGroupList = (input, context) => {
+    return input
+        .filter((e) => e != null)
+        .map((entry) => {
+        return serializeAws_restJson1WeightedTargetGroup(entry, context);
+    });
+};
+const deserializeAws_restJson1AccessLogSubscriptionList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1AccessLogSubscriptionSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1AccessLogSubscriptionSummary = (output, context) => {
+    return {
+        arn: __expectString(output.arn),
+        createdAt: output.createdAt != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdAt)) : undefined,
+        destinationArn: __expectString(output.destinationArn),
+        id: __expectString(output.id),
+        lastUpdatedAt: output.lastUpdatedAt != null
+            ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.lastUpdatedAt))
+            : undefined,
+        resourceArn: __expectString(output.resourceArn),
+        resourceId: __expectString(output.resourceId),
+    };
+};
+const deserializeAws_restJson1DnsEntry = (output, context) => {
+    return {
+        domainName: __expectString(output.domainName),
+        hostedZoneId: __expectString(output.hostedZoneId),
+    };
+};
+const deserializeAws_restJson1FixedResponseAction = (output, context) => {
+    return {
+        statusCode: __expectInt32(output.statusCode),
+    };
+};
+const deserializeAws_restJson1ForwardAction = (output, context) => {
+    return {
+        targetGroups: output.targetGroups != null
+            ? deserializeAws_restJson1WeightedTargetGroupList(output.targetGroups, context)
+            : undefined,
+    };
+};
+const deserializeAws_restJson1HeaderMatch = (output, context) => {
+    return {
+        caseSensitive: __expectBoolean(output.caseSensitive),
+        match: output.match != null ? deserializeAws_restJson1HeaderMatchType(__expectUnion(output.match), context) : undefined,
+        name: __expectString(output.name),
+    };
+};
+const deserializeAws_restJson1HeaderMatchList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1HeaderMatch(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1HeaderMatchType = (output, context) => {
+    if (__expectString(output.contains) !== undefined) {
+        return { contains: __expectString(output.contains) };
+    }
+    if (__expectString(output.exact) !== undefined) {
+        return { exact: __expectString(output.exact) };
+    }
+    if (__expectString(output.prefix) !== undefined) {
+        return { prefix: __expectString(output.prefix) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1HealthCheckConfig = (output, context) => {
+    return {
+        enabled: __expectBoolean(output.enabled),
+        healthCheckIntervalSeconds: __expectInt32(output.healthCheckIntervalSeconds),
+        healthCheckTimeoutSeconds: __expectInt32(output.healthCheckTimeoutSeconds),
+        healthyThresholdCount: __expectInt32(output.healthyThresholdCount),
+        matcher: output.matcher != null ? deserializeAws_restJson1Matcher(__expectUnion(output.matcher), context) : undefined,
+        path: __expectString(output.path),
+        port: __expectInt32(output.port),
+        protocol: __expectString(output.protocol),
+        protocolVersion: __expectString(output.protocolVersion),
+        unhealthyThresholdCount: __expectInt32(output.unhealthyThresholdCount),
+    };
+};
+const deserializeAws_restJson1HttpMatch = (output, context) => {
+    return {
+        headerMatches: output.headerMatches != null ? deserializeAws_restJson1HeaderMatchList(output.headerMatches, context) : undefined,
+        method: __expectString(output.method),
+        pathMatch: output.pathMatch != null ? deserializeAws_restJson1PathMatch(output.pathMatch, context) : undefined,
+    };
+};
+const deserializeAws_restJson1ListenerSummary = (output, context) => {
+    return {
+        arn: __expectString(output.arn),
+        createdAt: output.createdAt != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdAt)) : undefined,
+        id: __expectString(output.id),
+        lastUpdatedAt: output.lastUpdatedAt != null
+            ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.lastUpdatedAt))
+            : undefined,
+        name: __expectString(output.name),
+        port: __expectInt32(output.port),
+        protocol: __expectString(output.protocol),
+    };
+};
+const deserializeAws_restJson1ListenerSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ListenerSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1Matcher = (output, context) => {
+    if (__expectString(output.httpCode) !== undefined) {
+        return { httpCode: __expectString(output.httpCode) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1PathMatch = (output, context) => {
+    return {
+        caseSensitive: __expectBoolean(output.caseSensitive),
+        match: output.match != null ? deserializeAws_restJson1PathMatchType(__expectUnion(output.match), context) : undefined,
+    };
+};
+const deserializeAws_restJson1PathMatchType = (output, context) => {
+    if (__expectString(output.exact) !== undefined) {
+        return { exact: __expectString(output.exact) };
+    }
+    if (__expectString(output.prefix) !== undefined) {
+        return { prefix: __expectString(output.prefix) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1RuleAction = (output, context) => {
+    if (output.fixedResponse != null) {
+        return {
+            fixedResponse: deserializeAws_restJson1FixedResponseAction(output.fixedResponse, context),
+        };
+    }
+    if (output.forward != null) {
+        return {
+            forward: deserializeAws_restJson1ForwardAction(output.forward, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1RuleMatch = (output, context) => {
+    if (output.httpMatch != null) {
+        return {
+            httpMatch: deserializeAws_restJson1HttpMatch(output.httpMatch, context),
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const deserializeAws_restJson1RuleSummary = (output, context) => {
+    return {
+        arn: __expectString(output.arn),
+        createdAt: output.createdAt != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdAt)) : undefined,
+        id: __expectString(output.id),
+        isDefault: __expectBoolean(output.isDefault),
+        lastUpdatedAt: output.lastUpdatedAt != null
+            ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.lastUpdatedAt))
+            : undefined,
+        name: __expectString(output.name),
+        priority: __expectInt32(output.priority),
+    };
+};
+const deserializeAws_restJson1RuleSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1RuleSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1RuleUpdateFailure = (output, context) => {
+    return {
+        failureCode: __expectString(output.failureCode),
+        failureMessage: __expectString(output.failureMessage),
+        ruleIdentifier: __expectString(output.ruleIdentifier),
+    };
+};
+const deserializeAws_restJson1RuleUpdateFailureList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1RuleUpdateFailure(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1RuleUpdateSuccess = (output, context) => {
+    return {
+        action: output.action != null ? deserializeAws_restJson1RuleAction(__expectUnion(output.action), context) : undefined,
+        arn: __expectString(output.arn),
+        id: __expectString(output.id),
+        isDefault: __expectBoolean(output.isDefault),
+        match: output.match != null ? deserializeAws_restJson1RuleMatch(__expectUnion(output.match), context) : undefined,
+        name: __expectString(output.name),
+        priority: __expectInt32(output.priority),
+    };
+};
+const deserializeAws_restJson1RuleUpdateSuccessList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1RuleUpdateSuccess(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1SecurityGroupList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ServiceArnList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return __expectString(entry);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ServiceList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ServiceSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ServiceNetworkList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ServiceNetworkSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ServiceNetworkServiceAssociationList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ServiceNetworkServiceAssociationSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ServiceNetworkServiceAssociationSummary = (output, context) => {
+    return {
+        arn: __expectString(output.arn),
+        createdAt: output.createdAt != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdAt)) : undefined,
+        createdBy: __expectString(output.createdBy),
+        customDomainName: __expectString(output.customDomainName),
+        dnsEntry: output.dnsEntry != null ? deserializeAws_restJson1DnsEntry(output.dnsEntry, context) : undefined,
+        id: __expectString(output.id),
+        serviceArn: __expectString(output.serviceArn),
+        serviceId: __expectString(output.serviceId),
+        serviceName: __expectString(output.serviceName),
+        serviceNetworkArn: __expectString(output.serviceNetworkArn),
+        serviceNetworkId: __expectString(output.serviceNetworkId),
+        serviceNetworkName: __expectString(output.serviceNetworkName),
+        status: __expectString(output.status),
+    };
+};
+const deserializeAws_restJson1ServiceNetworkSummary = (output, context) => {
+    return {
+        arn: __expectString(output.arn),
+        createdAt: output.createdAt != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdAt)) : undefined,
+        id: __expectString(output.id),
+        lastUpdatedAt: output.lastUpdatedAt != null
+            ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.lastUpdatedAt))
+            : undefined,
+        name: __expectString(output.name),
+        numberOfAssociatedServices: __expectLong(output.numberOfAssociatedServices),
+        numberOfAssociatedVPCs: __expectLong(output.numberOfAssociatedVPCs),
+    };
+};
+const deserializeAws_restJson1ServiceNetworkVpcAssociationList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ServiceNetworkVpcAssociationSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ServiceNetworkVpcAssociationSummary = (output, context) => {
+    return {
+        arn: __expectString(output.arn),
+        createdAt: output.createdAt != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdAt)) : undefined,
+        createdBy: __expectString(output.createdBy),
+        id: __expectString(output.id),
+        lastUpdatedAt: output.lastUpdatedAt != null
+            ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.lastUpdatedAt))
+            : undefined,
+        serviceNetworkArn: __expectString(output.serviceNetworkArn),
+        serviceNetworkId: __expectString(output.serviceNetworkId),
+        serviceNetworkName: __expectString(output.serviceNetworkName),
+        status: __expectString(output.status),
+        vpcId: __expectString(output.vpcId),
+    };
+};
+const deserializeAws_restJson1ServiceSummary = (output, context) => {
+    return {
+        arn: __expectString(output.arn),
+        createdAt: output.createdAt != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdAt)) : undefined,
+        customDomainName: __expectString(output.customDomainName),
+        dnsEntry: output.dnsEntry != null ? deserializeAws_restJson1DnsEntry(output.dnsEntry, context) : undefined,
+        id: __expectString(output.id),
+        lastUpdatedAt: output.lastUpdatedAt != null
+            ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.lastUpdatedAt))
+            : undefined,
+        name: __expectString(output.name),
+        status: __expectString(output.status),
+    };
+};
+const deserializeAws_restJson1TagMap = (output, context) => {
+    return Object.entries(output).reduce((acc, [key, value]) => {
+        if (value === null) {
+            return acc;
+        }
+        acc[key] = __expectString(value);
+        return acc;
+    }, {});
+};
+const deserializeAws_restJson1Target = (output, context) => {
+    return {
+        id: __expectString(output.id),
+        port: __expectInt32(output.port),
+    };
+};
+const deserializeAws_restJson1TargetFailure = (output, context) => {
+    return {
+        failureCode: __expectString(output.failureCode),
+        failureMessage: __expectString(output.failureMessage),
+        id: __expectString(output.id),
+        port: __expectInt32(output.port),
+    };
+};
+const deserializeAws_restJson1TargetFailureList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1TargetFailure(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1TargetGroupConfig = (output, context) => {
+    return {
+        healthCheck: output.healthCheck != null ? deserializeAws_restJson1HealthCheckConfig(output.healthCheck, context) : undefined,
+        ipAddressType: __expectString(output.ipAddressType),
+        port: __expectInt32(output.port),
+        protocol: __expectString(output.protocol),
+        protocolVersion: __expectString(output.protocolVersion),
+        vpcIdentifier: __expectString(output.vpcIdentifier),
+    };
+};
+const deserializeAws_restJson1TargetGroupList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1TargetGroupSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1TargetGroupSummary = (output, context) => {
+    return {
+        arn: __expectString(output.arn),
+        createdAt: output.createdAt != null ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.createdAt)) : undefined,
+        id: __expectString(output.id),
+        ipAddressType: __expectString(output.ipAddressType),
+        lastUpdatedAt: output.lastUpdatedAt != null
+            ? __expectNonNull(__parseRfc3339DateTimeWithOffset(output.lastUpdatedAt))
+            : undefined,
+        name: __expectString(output.name),
+        port: __expectInt32(output.port),
+        protocol: __expectString(output.protocol),
+        serviceArns: output.serviceArns != null ? deserializeAws_restJson1ServiceArnList(output.serviceArns, context) : undefined,
+        status: __expectString(output.status),
+        type: __expectString(output.type),
+        vpcIdentifier: __expectString(output.vpcIdentifier),
+    };
+};
+const deserializeAws_restJson1TargetList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1Target(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1TargetSummary = (output, context) => {
+    return {
+        id: __expectString(output.id),
+        port: __expectInt32(output.port),
+        reasonCode: __expectString(output.reasonCode),
+        status: __expectString(output.status),
+    };
+};
+const deserializeAws_restJson1TargetSummaryList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1TargetSummary(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1ValidationExceptionField = (output, context) => {
+    return {
+        message: __expectString(output.message),
+        name: __expectString(output.name),
+    };
+};
+const deserializeAws_restJson1ValidationExceptionFieldList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1ValidationExceptionField(entry, context);
+    });
+    return retVal;
+};
+const deserializeAws_restJson1WeightedTargetGroup = (output, context) => {
+    return {
+        targetGroupIdentifier: __expectString(output.targetGroupIdentifier),
+        weight: __expectInt32(output.weight),
+    };
+};
+const deserializeAws_restJson1WeightedTargetGroupList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        if (entry === null) {
+            return null;
+        }
+        return deserializeAws_restJson1WeightedTargetGroup(entry, context);
+    });
+    return retVal;
+};
+const deserializeMetadata = (output) => ({
+    httpStatusCode: output.statusCode,
+    requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+    extendedRequestId: output.headers["x-amz-id-2"],
+    cfId: output.headers["x-amz-cf-id"],
+});
+const collectBody = (streamBody = new Uint8Array(), context) => {
+    if (streamBody instanceof Uint8Array) {
+        return Promise.resolve(streamBody);
+    }
+    return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
+};
+const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
+const isSerializableHeaderValue = (value) => value !== undefined &&
+    value !== null &&
+    value !== "" &&
+    (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) &&
+    (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0);
+const parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+    if (encoded.length) {
+        return JSON.parse(encoded);
+    }
+    return {};
+});
+const parseErrorBody = async (errorBody, context) => {
+    const value = await parseBody(errorBody, context);
+    value.message = value.message ?? value.Message;
+    return value;
+};
+const loadRestJsonErrorCode = (output, data) => {
+    const findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
+    const sanitizeErrorCode = (rawValue) => {
+        let cleanValue = rawValue;
+        if (typeof cleanValue === "number") {
+            cleanValue = cleanValue.toString();
+        }
+        if (cleanValue.indexOf(",") >= 0) {
+            cleanValue = cleanValue.split(",")[0];
+        }
+        if (cleanValue.indexOf(":") >= 0) {
+            cleanValue = cleanValue.split(":")[0];
+        }
+        if (cleanValue.indexOf("#") >= 0) {
+            cleanValue = cleanValue.split("#")[1];
+        }
+        return cleanValue;
+    };
+    const headerKey = findKey(output.headers, "x-amzn-errortype");
+    if (headerKey !== undefined) {
+        return sanitizeErrorCode(output.headers[headerKey]);
+    }
+    if (data.code !== undefined) {
+        return sanitizeErrorCode(data.code);
+    }
+    if (data["__type"] !== undefined) {
+        return sanitizeErrorCode(data["__type"]);
+    }
+};