@aws-sdk/client-app-mesh 3.490.0 → 3.496.0

package/dist-cjs/index.js

@@ -1,12 +1,4433 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppMeshServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./AppMeshClient"), exports);
-tslib_1.__exportStar(require("./AppMesh"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var AppMeshServiceException_1 = require("./models/AppMeshServiceException");
-Object.defineProperty(exports, "AppMeshServiceException", { enumerable: true, get: function () { return AppMeshServiceException_1.AppMeshServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AccessLog: () => AccessLog,
+  AppMesh: () => AppMesh,
+  AppMeshClient: () => AppMeshClient,
+  AppMeshServiceException: () => AppMeshServiceException,
+  Backend: () => Backend,
+  BadRequestException: () => BadRequestException,
+  ClientTlsCertificate: () => ClientTlsCertificate,
+  ConflictException: () => ConflictException,
+  CreateGatewayRouteCommand: () => CreateGatewayRouteCommand,
+  CreateMeshCommand: () => CreateMeshCommand,
+  CreateRouteCommand: () => CreateRouteCommand,
+  CreateVirtualGatewayCommand: () => CreateVirtualGatewayCommand,
+  CreateVirtualNodeCommand: () => CreateVirtualNodeCommand,
+  CreateVirtualRouterCommand: () => CreateVirtualRouterCommand,
+  CreateVirtualServiceCommand: () => CreateVirtualServiceCommand,
+  DefaultGatewayRouteRewrite: () => DefaultGatewayRouteRewrite,
+  DeleteGatewayRouteCommand: () => DeleteGatewayRouteCommand,
+  DeleteMeshCommand: () => DeleteMeshCommand,
+  DeleteRouteCommand: () => DeleteRouteCommand,
+  DeleteVirtualGatewayCommand: () => DeleteVirtualGatewayCommand,
+  DeleteVirtualNodeCommand: () => DeleteVirtualNodeCommand,
+  DeleteVirtualRouterCommand: () => DeleteVirtualRouterCommand,
+  DeleteVirtualServiceCommand: () => DeleteVirtualServiceCommand,
+  DescribeGatewayRouteCommand: () => DescribeGatewayRouteCommand,
+  DescribeMeshCommand: () => DescribeMeshCommand,
+  DescribeRouteCommand: () => DescribeRouteCommand,
+  DescribeVirtualGatewayCommand: () => DescribeVirtualGatewayCommand,
+  DescribeVirtualNodeCommand: () => DescribeVirtualNodeCommand,
+  DescribeVirtualRouterCommand: () => DescribeVirtualRouterCommand,
+  DescribeVirtualServiceCommand: () => DescribeVirtualServiceCommand,
+  DnsResponseType: () => DnsResponseType,
+  DurationUnit: () => DurationUnit,
+  EgressFilterType: () => EgressFilterType,
+  ForbiddenException: () => ForbiddenException,
+  GatewayRouteStatusCode: () => GatewayRouteStatusCode,
+  GrpcMetadataMatchMethod: () => GrpcMetadataMatchMethod,
+  GrpcRetryPolicyEvent: () => GrpcRetryPolicyEvent,
+  GrpcRouteMetadataMatchMethod: () => GrpcRouteMetadataMatchMethod,
+  HeaderMatchMethod: () => HeaderMatchMethod,
+  HttpMethod: () => HttpMethod,
+  HttpScheme: () => HttpScheme,
+  InternalServerErrorException: () => InternalServerErrorException,
+  IpPreference: () => IpPreference,
+  LimitExceededException: () => LimitExceededException,
+  ListGatewayRoutesCommand: () => ListGatewayRoutesCommand,
+  ListMeshesCommand: () => ListMeshesCommand,
+  ListRoutesCommand: () => ListRoutesCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ListVirtualGatewaysCommand: () => ListVirtualGatewaysCommand,
+  ListVirtualNodesCommand: () => ListVirtualNodesCommand,
+  ListVirtualRoutersCommand: () => ListVirtualRoutersCommand,
+  ListVirtualServicesCommand: () => ListVirtualServicesCommand,
+  ListenerTimeout: () => ListenerTimeout,
+  ListenerTlsCertificate: () => ListenerTlsCertificate,
+  ListenerTlsMode: () => ListenerTlsMode,
+  ListenerTlsValidationContextTrust: () => ListenerTlsValidationContextTrust,
+  LoggingFormat: () => LoggingFormat,
+  MeshStatusCode: () => MeshStatusCode,
+  NotFoundException: () => NotFoundException,
+  PortProtocol: () => PortProtocol,
+  ResourceInUseException: () => ResourceInUseException,
+  RouteStatusCode: () => RouteStatusCode,
+  ServiceDiscovery: () => ServiceDiscovery,
+  ServiceUnavailableException: () => ServiceUnavailableException,
+  TagResourceCommand: () => TagResourceCommand,
+  TcpRetryPolicyEvent: () => TcpRetryPolicyEvent,
+  TlsValidationContextTrust: () => TlsValidationContextTrust,
+  TooManyRequestsException: () => TooManyRequestsException,
+  TooManyTagsException: () => TooManyTagsException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateGatewayRouteCommand: () => UpdateGatewayRouteCommand,
+  UpdateMeshCommand: () => UpdateMeshCommand,
+  UpdateRouteCommand: () => UpdateRouteCommand,
+  UpdateVirtualGatewayCommand: () => UpdateVirtualGatewayCommand,
+  UpdateVirtualNodeCommand: () => UpdateVirtualNodeCommand,
+  UpdateVirtualRouterCommand: () => UpdateVirtualRouterCommand,
+  UpdateVirtualServiceCommand: () => UpdateVirtualServiceCommand,
+  VirtualGatewayAccessLog: () => VirtualGatewayAccessLog,
+  VirtualGatewayClientTlsCertificate: () => VirtualGatewayClientTlsCertificate,
+  VirtualGatewayConnectionPool: () => VirtualGatewayConnectionPool,
+  VirtualGatewayListenerTlsCertificate: () => VirtualGatewayListenerTlsCertificate,
+  VirtualGatewayListenerTlsMode: () => VirtualGatewayListenerTlsMode,
+  VirtualGatewayListenerTlsValidationContextTrust: () => VirtualGatewayListenerTlsValidationContextTrust,
+  VirtualGatewayPortProtocol: () => VirtualGatewayPortProtocol,
+  VirtualGatewayStatusCode: () => VirtualGatewayStatusCode,
+  VirtualGatewayTlsValidationContextTrust: () => VirtualGatewayTlsValidationContextTrust,
+  VirtualNodeConnectionPool: () => VirtualNodeConnectionPool,
+  VirtualNodeStatusCode: () => VirtualNodeStatusCode,
+  VirtualRouterStatusCode: () => VirtualRouterStatusCode,
+  VirtualServiceProvider: () => VirtualServiceProvider,
+  VirtualServiceStatusCode: () => VirtualServiceStatusCode,
+  __Client: () => import_smithy_client.Client,
+  paginateListGatewayRoutes: () => paginateListGatewayRoutes,
+  paginateListMeshes: () => paginateListMeshes,
+  paginateListRoutes: () => paginateListRoutes,
+  paginateListTagsForResource: () => paginateListTagsForResource,
+  paginateListVirtualGateways: () => paginateListVirtualGateways,
+  paginateListVirtualNodes: () => paginateListVirtualNodes,
+  paginateListVirtualRouters: () => paginateListVirtualRouters,
+  paginateListVirtualServices: () => paginateListVirtualServices
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/AppMeshClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "appmesh"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/AppMeshClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/AppMeshClient.ts
+var _AppMeshClient = class _AppMeshClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_AppMeshClient, "AppMeshClient");
+var AppMeshClient = _AppMeshClient;
+
+// src/AppMesh.ts
+
+
+// src/commands/CreateGatewayRouteCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@smithy/core");
+
+var import_uuid = require("uuid");
+
+// src/models/AppMeshServiceException.ts
+
+var _AppMeshServiceException = class _AppMeshServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _AppMeshServiceException.prototype);
+  }
+};
+__name(_AppMeshServiceException, "AppMeshServiceException");
+var AppMeshServiceException = _AppMeshServiceException;
+
+// src/models/models_0.ts
+var LoggingFormat;
+((LoggingFormat3) => {
+  LoggingFormat3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.text !== void 0)
+      return visitor.text(value.text);
+    if (value.json !== void 0)
+      return visitor.json(value.json);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(LoggingFormat || (LoggingFormat = {}));
+var AccessLog;
+((AccessLog3) => {
+  AccessLog3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.file !== void 0)
+      return visitor.file(value.file);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(AccessLog || (AccessLog = {}));
+var _BadRequestException = class _BadRequestException extends AppMeshServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "BadRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "BadRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _BadRequestException.prototype);
+  }
+};
+__name(_BadRequestException, "BadRequestException");
+var BadRequestException = _BadRequestException;
+var _ForbiddenException = class _ForbiddenException extends AppMeshServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ForbiddenException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ForbiddenException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ForbiddenException.prototype);
+  }
+};
+__name(_ForbiddenException, "ForbiddenException");
+var ForbiddenException = _ForbiddenException;
+var _InternalServerErrorException = class _InternalServerErrorException extends AppMeshServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerErrorException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerErrorException";
+    this.$fault = "server";
+    this.$retryable = {};
+    Object.setPrototypeOf(this, _InternalServerErrorException.prototype);
+  }
+};
+__name(_InternalServerErrorException, "InternalServerErrorException");
+var InternalServerErrorException = _InternalServerErrorException;
+var _NotFoundException = class _NotFoundException extends AppMeshServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NotFoundException.prototype);
+  }
+};
+__name(_NotFoundException, "NotFoundException");
+var NotFoundException = _NotFoundException;
+var _ServiceUnavailableException = class _ServiceUnavailableException extends AppMeshServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceUnavailableException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "ServiceUnavailableException";
+    this.$fault = "server";
+    this.$retryable = {};
+    Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
+  }
+};
+__name(_ServiceUnavailableException, "ServiceUnavailableException");
+var ServiceUnavailableException = _ServiceUnavailableException;
+var _TooManyRequestsException = class _TooManyRequestsException extends AppMeshServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyRequestsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyRequestsException";
+    this.$fault = "client";
+    this.$retryable = {
+      throttling: true
+    };
+    Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
+  }
+};
+__name(_TooManyRequestsException, "TooManyRequestsException");
+var TooManyRequestsException = _TooManyRequestsException;
+var _ConflictException = class _ConflictException extends AppMeshServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var EgressFilterType = {
+  ALLOW_ALL: "ALLOW_ALL",
+  DROP_ALL: "DROP_ALL"
+};
+var IpPreference = {
+  IPv4_ONLY: "IPv4_ONLY",
+  IPv4_PREFERRED: "IPv4_PREFERRED",
+  IPv6_ONLY: "IPv6_ONLY",
+  IPv6_PREFERRED: "IPv6_PREFERRED"
+};
+var MeshStatusCode = {
+  ACTIVE: "ACTIVE",
+  DELETED: "DELETED",
+  INACTIVE: "INACTIVE"
+};
+var _LimitExceededException = class _LimitExceededException extends AppMeshServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var _ResourceInUseException = class _ResourceInUseException extends AppMeshServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceInUseException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceInUseException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceInUseException.prototype);
+  }
+};
+__name(_ResourceInUseException, "ResourceInUseException");
+var ResourceInUseException = _ResourceInUseException;
+var VirtualGatewayClientTlsCertificate;
+((VirtualGatewayClientTlsCertificate3) => {
+  VirtualGatewayClientTlsCertificate3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.file !== void 0)
+      return visitor.file(value.file);
+    if (value.sds !== void 0)
+      return visitor.sds(value.sds);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(VirtualGatewayClientTlsCertificate || (VirtualGatewayClientTlsCertificate = {}));
+var VirtualGatewayTlsValidationContextTrust;
+((VirtualGatewayTlsValidationContextTrust3) => {
+  VirtualGatewayTlsValidationContextTrust3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.acm !== void 0)
+      return visitor.acm(value.acm);
+    if (value.file !== void 0)
+      return visitor.file(value.file);
+    if (value.sds !== void 0)
+      return visitor.sds(value.sds);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(VirtualGatewayTlsValidationContextTrust || (VirtualGatewayTlsValidationContextTrust = {}));
+var VirtualGatewayConnectionPool;
+((VirtualGatewayConnectionPool3) => {
+  VirtualGatewayConnectionPool3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.http !== void 0)
+      return visitor.http(value.http);
+    if (value.http2 !== void 0)
+      return visitor.http2(value.http2);
+    if (value.grpc !== void 0)
+      return visitor.grpc(value.grpc);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(VirtualGatewayConnectionPool || (VirtualGatewayConnectionPool = {}));
+var VirtualGatewayPortProtocol = {
+  GRPC: "grpc",
+  HTTP: "http",
+  HTTP2: "http2"
+};
+var VirtualGatewayListenerTlsCertificate;
+((VirtualGatewayListenerTlsCertificate3) => {
+  VirtualGatewayListenerTlsCertificate3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.acm !== void 0)
+      return visitor.acm(value.acm);
+    if (value.file !== void 0)
+      return visitor.file(value.file);
+    if (value.sds !== void 0)
+      return visitor.sds(value.sds);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(VirtualGatewayListenerTlsCertificate || (VirtualGatewayListenerTlsCertificate = {}));
+var VirtualGatewayListenerTlsMode = {
+  DISABLED: "DISABLED",
+  PERMISSIVE: "PERMISSIVE",
+  STRICT: "STRICT"
+};
+var VirtualGatewayListenerTlsValidationContextTrust;
+((VirtualGatewayListenerTlsValidationContextTrust3) => {
+  VirtualGatewayListenerTlsValidationContextTrust3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.file !== void 0)
+      return visitor.file(value.file);
+    if (value.sds !== void 0)
+      return visitor.sds(value.sds);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(VirtualGatewayListenerTlsValidationContextTrust || (VirtualGatewayListenerTlsValidationContextTrust = {}));
+var VirtualGatewayAccessLog;
+((VirtualGatewayAccessLog3) => {
+  VirtualGatewayAccessLog3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.file !== void 0)
+      return visitor.file(value.file);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(VirtualGatewayAccessLog || (VirtualGatewayAccessLog = {}));
+var VirtualGatewayStatusCode = {
+  ACTIVE: "ACTIVE",
+  DELETED: "DELETED",
+  INACTIVE: "INACTIVE"
+};
+var DefaultGatewayRouteRewrite = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var GrpcMetadataMatchMethod;
+((GrpcMetadataMatchMethod3) => {
+  GrpcMetadataMatchMethod3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.exact !== void 0)
+      return visitor.exact(value.exact);
+    if (value.regex !== void 0)
+      return visitor.regex(value.regex);
+    if (value.range !== void 0)
+      return visitor.range(value.range);
+    if (value.prefix !== void 0)
+      return visitor.prefix(value.prefix);
+    if (value.suffix !== void 0)
+      return visitor.suffix(value.suffix);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(GrpcMetadataMatchMethod || (GrpcMetadataMatchMethod = {}));
+var HeaderMatchMethod;
+((HeaderMatchMethod3) => {
+  HeaderMatchMethod3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.exact !== void 0)
+      return visitor.exact(value.exact);
+    if (value.regex !== void 0)
+      return visitor.regex(value.regex);
+    if (value.range !== void 0)
+      return visitor.range(value.range);
+    if (value.prefix !== void 0)
+      return visitor.prefix(value.prefix);
+    if (value.suffix !== void 0)
+      return visitor.suffix(value.suffix);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(HeaderMatchMethod || (HeaderMatchMethod = {}));
+var HttpMethod = {
+  CONNECT: "CONNECT",
+  DELETE: "DELETE",
+  GET: "GET",
+  HEAD: "HEAD",
+  OPTIONS: "OPTIONS",
+  PATCH: "PATCH",
+  POST: "POST",
+  PUT: "PUT",
+  TRACE: "TRACE"
+};
+var GatewayRouteStatusCode = {
+  ACTIVE: "ACTIVE",
+  DELETED: "DELETED",
+  INACTIVE: "INACTIVE"
+};
+var ClientTlsCertificate;
+((ClientTlsCertificate3) => {
+  ClientTlsCertificate3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.file !== void 0)
+      return visitor.file(value.file);
+    if (value.sds !== void 0)
+      return visitor.sds(value.sds);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ClientTlsCertificate || (ClientTlsCertificate = {}));
+var TlsValidationContextTrust;
+((TlsValidationContextTrust3) => {
+  TlsValidationContextTrust3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.acm !== void 0)
+      return visitor.acm(value.acm);
+    if (value.file !== void 0)
+      return visitor.file(value.file);
+    if (value.sds !== void 0)
+      return visitor.sds(value.sds);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(TlsValidationContextTrust || (TlsValidationContextTrust = {}));
+var Backend;
+((Backend3) => {
+  Backend3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.virtualService !== void 0)
+      return visitor.virtualService(value.virtualService);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Backend || (Backend = {}));
+var VirtualNodeConnectionPool;
+((VirtualNodeConnectionPool3) => {
+  VirtualNodeConnectionPool3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.tcp !== void 0)
+      return visitor.tcp(value.tcp);
+    if (value.http !== void 0)
+      return visitor.http(value.http);
+    if (value.http2 !== void 0)
+      return visitor.http2(value.http2);
+    if (value.grpc !== void 0)
+      return visitor.grpc(value.grpc);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(VirtualNodeConnectionPool || (VirtualNodeConnectionPool = {}));
+var PortProtocol = {
+  GRPC: "grpc",
+  HTTP: "http",
+  HTTP2: "http2",
+  TCP: "tcp"
+};
+var DurationUnit = {
+  MS: "ms",
+  S: "s"
+};
+var ListenerTimeout;
+((ListenerTimeout3) => {
+  ListenerTimeout3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.tcp !== void 0)
+      return visitor.tcp(value.tcp);
+    if (value.http !== void 0)
+      return visitor.http(value.http);
+    if (value.http2 !== void 0)
+      return visitor.http2(value.http2);
+    if (value.grpc !== void 0)
+      return visitor.grpc(value.grpc);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ListenerTimeout || (ListenerTimeout = {}));
+var ListenerTlsCertificate;
+((ListenerTlsCertificate3) => {
+  ListenerTlsCertificate3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.acm !== void 0)
+      return visitor.acm(value.acm);
+    if (value.file !== void 0)
+      return visitor.file(value.file);
+    if (value.sds !== void 0)
+      return visitor.sds(value.sds);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ListenerTlsCertificate || (ListenerTlsCertificate = {}));
+var ListenerTlsMode = {
+  DISABLED: "DISABLED",
+  PERMISSIVE: "PERMISSIVE",
+  STRICT: "STRICT"
+};
+var ListenerTlsValidationContextTrust;
+((ListenerTlsValidationContextTrust3) => {
+  ListenerTlsValidationContextTrust3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.file !== void 0)
+      return visitor.file(value.file);
+    if (value.sds !== void 0)
+      return visitor.sds(value.sds);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ListenerTlsValidationContextTrust || (ListenerTlsValidationContextTrust = {}));
+var DnsResponseType = {
+  ENDPOINTS: "ENDPOINTS",
+  LOADBALANCER: "LOADBALANCER"
+};
+var ServiceDiscovery;
+((ServiceDiscovery3) => {
+  ServiceDiscovery3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.dns !== void 0)
+      return visitor.dns(value.dns);
+    if (value.awsCloudMap !== void 0)
+      return visitor.awsCloudMap(value.awsCloudMap);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ServiceDiscovery || (ServiceDiscovery = {}));
+var VirtualNodeStatusCode = {
+  ACTIVE: "ACTIVE",
+  DELETED: "DELETED",
+  INACTIVE: "INACTIVE"
+};
+var VirtualRouterStatusCode = {
+  ACTIVE: "ACTIVE",
+  DELETED: "DELETED",
+  INACTIVE: "INACTIVE"
+};
+var GrpcRouteMetadataMatchMethod;
+((GrpcRouteMetadataMatchMethod3) => {
+  GrpcRouteMetadataMatchMethod3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.exact !== void 0)
+      return visitor.exact(value.exact);
+    if (value.regex !== void 0)
+      return visitor.regex(value.regex);
+    if (value.range !== void 0)
+      return visitor.range(value.range);
+    if (value.prefix !== void 0)
+      return visitor.prefix(value.prefix);
+    if (value.suffix !== void 0)
+      return visitor.suffix(value.suffix);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(GrpcRouteMetadataMatchMethod || (GrpcRouteMetadataMatchMethod = {}));
+var GrpcRetryPolicyEvent = {
+  CANCELLED: "cancelled",
+  DEADLINE_EXCEEDED: "deadline-exceeded",
+  INTERNAL: "internal",
+  RESOURCE_EXHAUSTED: "resource-exhausted",
+  UNAVAILABLE: "unavailable"
+};
+var TcpRetryPolicyEvent = {
+  CONNECTION_ERROR: "connection-error"
+};
+var HttpScheme = {
+  HTTP: "http",
+  HTTPS: "https"
+};
+var RouteStatusCode = {
+  ACTIVE: "ACTIVE",
+  DELETED: "DELETED",
+  INACTIVE: "INACTIVE"
+};
+var VirtualServiceProvider;
+((VirtualServiceProvider3) => {
+  VirtualServiceProvider3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.virtualNode !== void 0)
+      return visitor.virtualNode(value.virtualNode);
+    if (value.virtualRouter !== void 0)
+      return visitor.virtualRouter(value.virtualRouter);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(VirtualServiceProvider || (VirtualServiceProvider = {}));
+var VirtualServiceStatusCode = {
+  ACTIVE: "ACTIVE",
+  DELETED: "DELETED",
+  INACTIVE: "INACTIVE"
+};
+var _TooManyTagsException = class _TooManyTagsException extends AppMeshServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTagsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTagsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
+  }
+};
+__name(_TooManyTagsException, "TooManyTagsException");
+var TooManyTagsException = _TooManyTagsException;
+
+// src/protocols/Aws_restJson1.ts
+var se_CreateGatewayRouteCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      gatewayRouteName: [],
+      spec: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_CreateGatewayRouteCommand");
+var se_CreateMeshCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      meshName: [],
+      spec: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_CreateMeshCommand");
+var se_CreateRouteCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      routeName: [],
+      spec: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_CreateRouteCommand");
+var se_CreateVirtualGatewayCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualGateways");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      spec: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_),
+      virtualGatewayName: []
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_CreateVirtualGatewayCommand");
+var se_CreateVirtualNodeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualNodes");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      spec: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_),
+      virtualNodeName: []
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_CreateVirtualNodeCommand");
+var se_CreateVirtualRouterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualRouters");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      spec: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_),
+      virtualRouterName: []
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_CreateVirtualRouterCommand");
+var se_CreateVirtualServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualServices");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      spec: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_),
+      virtualServiceName: []
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_CreateVirtualServiceCommand");
+var se_DeleteGatewayRouteCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}");
+  b.p("gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteGatewayRouteCommand");
+var se_DeleteMeshCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteMeshCommand");
+var se_DeleteRouteCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}");
+  b.p("routeName", () => input.routeName, "{routeName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteRouteCommand");
+var se_DeleteVirtualGatewayCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}");
+  b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteVirtualGatewayCommand");
+var se_DeleteVirtualNodeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}");
+  b.p("virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteVirtualNodeCommand");
+var se_DeleteVirtualRouterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}");
+  b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteVirtualRouterCommand");
+var se_DeleteVirtualServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}");
+  b.p("virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteVirtualServiceCommand");
+var se_DescribeGatewayRouteCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}");
+  b.p("gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeGatewayRouteCommand");
+var se_DescribeMeshCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeMeshCommand");
+var se_DescribeRouteCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}");
+  b.p("routeName", () => input.routeName, "{routeName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeRouteCommand");
+var se_DescribeVirtualGatewayCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}");
+  b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeVirtualGatewayCommand");
+var se_DescribeVirtualNodeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}");
+  b.p("virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeVirtualNodeCommand");
+var se_DescribeVirtualRouterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}");
+  b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeVirtualRouterCommand");
+var se_DescribeVirtualServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}");
+  b.p("virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DescribeVirtualServiceCommand");
+var se_ListGatewayRoutesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_nT]: [, input[_nT]],
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListGatewayRoutesCommand");
+var se_ListMeshesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes");
+  const query = (0, import_smithy_client.map)({
+    [_nT]: [, input[_nT]],
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListMeshesCommand");
+var se_ListRoutesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_nT]: [, input[_nT]],
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListRoutesCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/tags");
+  const query = (0, import_smithy_client.map)({
+    [_rA]: [, (0, import_smithy_client.expectNonNull)(input[_rA], `resourceArn`)],
+    [_nT]: [, input[_nT]],
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_ListVirtualGatewaysCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualGateways");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_nT]: [, input[_nT]],
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListVirtualGatewaysCommand");
+var se_ListVirtualNodesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualNodes");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_nT]: [, input[_nT]],
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListVirtualNodesCommand");
+var se_ListVirtualRoutersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualRouters");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_nT]: [, input[_nT]],
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListVirtualRoutersCommand");
+var se_ListVirtualServicesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/v20190125/meshes/{meshName}/virtualServices");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_nT]: [, input[_nT]],
+    [_l]: [() => input.limit !== void 0, () => input[_l].toString()],
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListVirtualServicesCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/tag");
+  const query = (0, import_smithy_client.map)({
+    [_rA]: [, (0, import_smithy_client.expectNonNull)(input[_rA], `resourceArn`)]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/untag");
+  const query = (0, import_smithy_client.map)({
+    [_rA]: [, (0, import_smithy_client.expectNonNull)(input[_rA], `resourceArn`)]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      tagKeys: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateGatewayRouteCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualGateway/{virtualGatewayName}/gatewayRoutes/{gatewayRouteName}");
+  b.p("gatewayRouteName", () => input.gatewayRouteName, "{gatewayRouteName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      spec: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UpdateGatewayRouteCommand");
+var se_UpdateMeshCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}");
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      spec: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateMeshCommand");
+var se_UpdateRouteCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualRouter/{virtualRouterName}/routes/{routeName}");
+  b.p("routeName", () => input.routeName, "{routeName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      spec: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UpdateRouteCommand");
+var se_UpdateVirtualGatewayCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualGateways/{virtualGatewayName}");
+  b.p("virtualGatewayName", () => input.virtualGatewayName, "{virtualGatewayName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      spec: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UpdateVirtualGatewayCommand");
+var se_UpdateVirtualNodeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualNodes/{virtualNodeName}");
+  b.p("virtualNodeName", () => input.virtualNodeName, "{virtualNodeName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      spec: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UpdateVirtualNodeCommand");
+var se_UpdateVirtualRouterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualRouters/{virtualRouterName}");
+  b.p("virtualRouterName", () => input.virtualRouterName, "{virtualRouterName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      spec: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UpdateVirtualRouterCommand");
+var se_UpdateVirtualServiceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/v20190125/meshes/{meshName}/virtualServices/{virtualServiceName}");
+  b.p("virtualServiceName", () => input.virtualServiceName, "{virtualServiceName}", false);
+  b.p("meshName", () => input.meshName, "{meshName}", false);
+  const query = (0, import_smithy_client.map)({
+    [_mO]: [, input[_mO]]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      spec: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("PUT").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UpdateVirtualServiceCommand");
+var de_CreateGatewayRouteCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateGatewayRouteCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.gatewayRoute = de_GatewayRouteData(data, context);
+  return contents;
+}, "de_CreateGatewayRouteCommand");
+var de_CreateGatewayRouteCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateGatewayRouteCommandError");
+var de_CreateMeshCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateMeshCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.mesh = de_MeshData(data, context);
+  return contents;
+}, "de_CreateMeshCommand");
+var de_CreateMeshCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateMeshCommandError");
+var de_CreateRouteCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateRouteCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.route = de_RouteData(data, context);
+  return contents;
+}, "de_CreateRouteCommand");
+var de_CreateRouteCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateRouteCommandError");
+var de_CreateVirtualGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateVirtualGatewayCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualGateway = de_VirtualGatewayData(data, context);
+  return contents;
+}, "de_CreateVirtualGatewayCommand");
+var de_CreateVirtualGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateVirtualGatewayCommandError");
+var de_CreateVirtualNodeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateVirtualNodeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualNode = de_VirtualNodeData(data, context);
+  return contents;
+}, "de_CreateVirtualNodeCommand");
+var de_CreateVirtualNodeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateVirtualNodeCommandError");
+var de_CreateVirtualRouterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateVirtualRouterCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualRouter = de_VirtualRouterData(data, context);
+  return contents;
+}, "de_CreateVirtualRouterCommand");
+var de_CreateVirtualRouterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateVirtualRouterCommandError");
+var de_CreateVirtualServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CreateVirtualServiceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualService = de_VirtualServiceData(data, context);
+  return contents;
+}, "de_CreateVirtualServiceCommand");
+var de_CreateVirtualServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateVirtualServiceCommandError");
+var de_DeleteGatewayRouteCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteGatewayRouteCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.gatewayRoute = de_GatewayRouteData(data, context);
+  return contents;
+}, "de_DeleteGatewayRouteCommand");
+var de_DeleteGatewayRouteCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.appmesh#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteGatewayRouteCommandError");
+var de_DeleteMeshCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteMeshCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.mesh = de_MeshData(data, context);
+  return contents;
+}, "de_DeleteMeshCommand");
+var de_DeleteMeshCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.appmesh#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteMeshCommandError");
+var de_DeleteRouteCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteRouteCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.route = de_RouteData(data, context);
+  return contents;
+}, "de_DeleteRouteCommand");
+var de_DeleteRouteCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.appmesh#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteRouteCommandError");
+var de_DeleteVirtualGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteVirtualGatewayCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualGateway = de_VirtualGatewayData(data, context);
+  return contents;
+}, "de_DeleteVirtualGatewayCommand");
+var de_DeleteVirtualGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.appmesh#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVirtualGatewayCommandError");
+var de_DeleteVirtualNodeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteVirtualNodeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualNode = de_VirtualNodeData(data, context);
+  return contents;
+}, "de_DeleteVirtualNodeCommand");
+var de_DeleteVirtualNodeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.appmesh#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVirtualNodeCommandError");
+var de_DeleteVirtualRouterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteVirtualRouterCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualRouter = de_VirtualRouterData(data, context);
+  return contents;
+}, "de_DeleteVirtualRouterCommand");
+var de_DeleteVirtualRouterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.appmesh#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVirtualRouterCommandError");
+var de_DeleteVirtualServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteVirtualServiceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualService = de_VirtualServiceData(data, context);
+  return contents;
+}, "de_DeleteVirtualServiceCommand");
+var de_DeleteVirtualServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ResourceInUseException":
+    case "com.amazonaws.appmesh#ResourceInUseException":
+      throw await de_ResourceInUseExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVirtualServiceCommandError");
+var de_DescribeGatewayRouteCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeGatewayRouteCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.gatewayRoute = de_GatewayRouteData(data, context);
+  return contents;
+}, "de_DescribeGatewayRouteCommand");
+var de_DescribeGatewayRouteCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeGatewayRouteCommandError");
+var de_DescribeMeshCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeMeshCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.mesh = de_MeshData(data, context);
+  return contents;
+}, "de_DescribeMeshCommand");
+var de_DescribeMeshCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeMeshCommandError");
+var de_DescribeRouteCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeRouteCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.route = de_RouteData(data, context);
+  return contents;
+}, "de_DescribeRouteCommand");
+var de_DescribeRouteCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeRouteCommandError");
+var de_DescribeVirtualGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeVirtualGatewayCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualGateway = de_VirtualGatewayData(data, context);
+  return contents;
+}, "de_DescribeVirtualGatewayCommand");
+var de_DescribeVirtualGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeVirtualGatewayCommandError");
+var de_DescribeVirtualNodeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeVirtualNodeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualNode = de_VirtualNodeData(data, context);
+  return contents;
+}, "de_DescribeVirtualNodeCommand");
+var de_DescribeVirtualNodeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeVirtualNodeCommandError");
+var de_DescribeVirtualRouterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeVirtualRouterCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualRouter = de_VirtualRouterData(data, context);
+  return contents;
+}, "de_DescribeVirtualRouterCommand");
+var de_DescribeVirtualRouterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeVirtualRouterCommandError");
+var de_DescribeVirtualServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DescribeVirtualServiceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualService = de_VirtualServiceData(data, context);
+  return contents;
+}, "de_DescribeVirtualServiceCommand");
+var de_DescribeVirtualServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeVirtualServiceCommandError");
+var de_ListGatewayRoutesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListGatewayRoutesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    gatewayRoutes: (_) => de_GatewayRouteList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListGatewayRoutesCommand");
+var de_ListGatewayRoutesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListGatewayRoutesCommandError");
+var de_ListMeshesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListMeshesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    meshes: (_) => de_MeshList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListMeshesCommand");
+var de_ListMeshesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListMeshesCommandError");
+var de_ListRoutesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListRoutesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    routes: (_) => de_RouteList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListRoutesCommand");
+var de_ListRoutesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListRoutesCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ListVirtualGatewaysCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListVirtualGatewaysCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    virtualGateways: (_) => de_VirtualGatewayList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListVirtualGatewaysCommand");
+var de_ListVirtualGatewaysCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListVirtualGatewaysCommandError");
+var de_ListVirtualNodesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListVirtualNodesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    virtualNodes: (_) => de_VirtualNodeList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListVirtualNodesCommand");
+var de_ListVirtualNodesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListVirtualNodesCommandError");
+var de_ListVirtualRoutersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListVirtualRoutersCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    virtualRouters: (_) => de_VirtualRouterList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListVirtualRoutersCommand");
+var de_ListVirtualRoutersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListVirtualRoutersCommandError");
+var de_ListVirtualServicesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListVirtualServicesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    virtualServices: (_) => de_VirtualServiceList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListVirtualServicesCommand");
+var de_ListVirtualServicesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListVirtualServicesCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.appmesh#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateGatewayRouteCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateGatewayRouteCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.gatewayRoute = de_GatewayRouteData(data, context);
+  return contents;
+}, "de_UpdateGatewayRouteCommand");
+var de_UpdateGatewayRouteCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateGatewayRouteCommandError");
+var de_UpdateMeshCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateMeshCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.mesh = de_MeshData(data, context);
+  return contents;
+}, "de_UpdateMeshCommand");
+var de_UpdateMeshCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateMeshCommandError");
+var de_UpdateRouteCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateRouteCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.route = de_RouteData(data, context);
+  return contents;
+}, "de_UpdateRouteCommand");
+var de_UpdateRouteCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateRouteCommandError");
+var de_UpdateVirtualGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateVirtualGatewayCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualGateway = de_VirtualGatewayData(data, context);
+  return contents;
+}, "de_UpdateVirtualGatewayCommand");
+var de_UpdateVirtualGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateVirtualGatewayCommandError");
+var de_UpdateVirtualNodeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateVirtualNodeCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualNode = de_VirtualNodeData(data, context);
+  return contents;
+}, "de_UpdateVirtualNodeCommand");
+var de_UpdateVirtualNodeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateVirtualNodeCommandError");
+var de_UpdateVirtualRouterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateVirtualRouterCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualRouter = de_VirtualRouterData(data, context);
+  return contents;
+}, "de_UpdateVirtualRouterCommand");
+var de_UpdateVirtualRouterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateVirtualRouterCommandError");
+var de_UpdateVirtualServiceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_UpdateVirtualServiceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectObject)(await parseBody(output.body, context));
+  contents.virtualService = de_VirtualServiceData(data, context);
+  return contents;
+}, "de_UpdateVirtualServiceCommand");
+var de_UpdateVirtualServiceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "BadRequestException":
+    case "com.amazonaws.appmesh#BadRequestException":
+      throw await de_BadRequestExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.appmesh#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "ForbiddenException":
+    case "com.amazonaws.appmesh#ForbiddenException":
+      throw await de_ForbiddenExceptionRes(parsedOutput, context);
+    case "InternalServerErrorException":
+    case "com.amazonaws.appmesh#InternalServerErrorException":
+      throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.appmesh#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "NotFoundException":
+    case "com.amazonaws.appmesh#NotFoundException":
+      throw await de_NotFoundExceptionRes(parsedOutput, context);
+    case "ServiceUnavailableException":
+    case "com.amazonaws.appmesh#ServiceUnavailableException":
+      throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
+    case "TooManyRequestsException":
+    case "com.amazonaws.appmesh#TooManyRequestsException":
+      throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateVirtualServiceCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(AppMeshServiceException);
+var de_BadRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new BadRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_BadRequestExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_ForbiddenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ForbiddenException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ForbiddenExceptionRes");
+var de_InternalServerErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerErrorException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerErrorExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_LimitExceededExceptionRes");
+var de_NotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new NotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_NotFoundExceptionRes");
+var de_ResourceInUseExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceInUseException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceInUseExceptionRes");
+var de_ServiceUnavailableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceUnavailableException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceUnavailableExceptionRes");
+var de_TooManyRequestsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new TooManyRequestsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TooManyRequestsExceptionRes");
+var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new TooManyTagsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_TooManyTagsExceptionRes");
+var de_GatewayRouteData = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    gatewayRouteName: import_smithy_client.expectString,
+    meshName: import_smithy_client.expectString,
+    metadata: (_) => de_ResourceMetadata(_, context),
+    spec: import_smithy_client._json,
+    status: import_smithy_client._json,
+    virtualGatewayName: import_smithy_client.expectString
+  });
+}, "de_GatewayRouteData");
+var de_GatewayRouteList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_GatewayRouteRef(entry, context);
+  });
+  return retVal;
+}, "de_GatewayRouteList");
+var de_GatewayRouteRef = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    gatewayRouteName: import_smithy_client.expectString,
+    lastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    meshName: import_smithy_client.expectString,
+    meshOwner: import_smithy_client.expectString,
+    resourceOwner: import_smithy_client.expectString,
+    version: import_smithy_client.expectLong,
+    virtualGatewayName: import_smithy_client.expectString
+  });
+}, "de_GatewayRouteRef");
+var de_MeshData = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    meshName: import_smithy_client.expectString,
+    metadata: (_) => de_ResourceMetadata(_, context),
+    spec: import_smithy_client._json,
+    status: import_smithy_client._json
+  });
+}, "de_MeshData");
+var de_MeshList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MeshRef(entry, context);
+  });
+  return retVal;
+}, "de_MeshList");
+var de_MeshRef = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    meshName: import_smithy_client.expectString,
+    meshOwner: import_smithy_client.expectString,
+    resourceOwner: import_smithy_client.expectString,
+    version: import_smithy_client.expectLong
+  });
+}, "de_MeshRef");
+var de_ResourceMetadata = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    meshOwner: import_smithy_client.expectString,
+    resourceOwner: import_smithy_client.expectString,
+    uid: import_smithy_client.expectString,
+    version: import_smithy_client.expectLong
+  });
+}, "de_ResourceMetadata");
+var de_RouteData = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    meshName: import_smithy_client.expectString,
+    metadata: (_) => de_ResourceMetadata(_, context),
+    routeName: import_smithy_client.expectString,
+    spec: import_smithy_client._json,
+    status: import_smithy_client._json,
+    virtualRouterName: import_smithy_client.expectString
+  });
+}, "de_RouteData");
+var de_RouteList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_RouteRef(entry, context);
+  });
+  return retVal;
+}, "de_RouteList");
+var de_RouteRef = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    meshName: import_smithy_client.expectString,
+    meshOwner: import_smithy_client.expectString,
+    resourceOwner: import_smithy_client.expectString,
+    routeName: import_smithy_client.expectString,
+    version: import_smithy_client.expectLong,
+    virtualRouterName: import_smithy_client.expectString
+  });
+}, "de_RouteRef");
+var de_VirtualGatewayData = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    meshName: import_smithy_client.expectString,
+    metadata: (_) => de_ResourceMetadata(_, context),
+    spec: import_smithy_client._json,
+    status: import_smithy_client._json,
+    virtualGatewayName: import_smithy_client.expectString
+  });
+}, "de_VirtualGatewayData");
+var de_VirtualGatewayList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_VirtualGatewayRef(entry, context);
+  });
+  return retVal;
+}, "de_VirtualGatewayList");
+var de_VirtualGatewayRef = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    meshName: import_smithy_client.expectString,
+    meshOwner: import_smithy_client.expectString,
+    resourceOwner: import_smithy_client.expectString,
+    version: import_smithy_client.expectLong,
+    virtualGatewayName: import_smithy_client.expectString
+  });
+}, "de_VirtualGatewayRef");
+var de_VirtualNodeData = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    meshName: import_smithy_client.expectString,
+    metadata: (_) => de_ResourceMetadata(_, context),
+    spec: import_smithy_client._json,
+    status: import_smithy_client._json,
+    virtualNodeName: import_smithy_client.expectString
+  });
+}, "de_VirtualNodeData");
+var de_VirtualNodeList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_VirtualNodeRef(entry, context);
+  });
+  return retVal;
+}, "de_VirtualNodeList");
+var de_VirtualNodeRef = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    meshName: import_smithy_client.expectString,
+    meshOwner: import_smithy_client.expectString,
+    resourceOwner: import_smithy_client.expectString,
+    version: import_smithy_client.expectLong,
+    virtualNodeName: import_smithy_client.expectString
+  });
+}, "de_VirtualNodeRef");
+var de_VirtualRouterData = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    meshName: import_smithy_client.expectString,
+    metadata: (_) => de_ResourceMetadata(_, context),
+    spec: import_smithy_client._json,
+    status: import_smithy_client._json,
+    virtualRouterName: import_smithy_client.expectString
+  });
+}, "de_VirtualRouterData");
+var de_VirtualRouterList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_VirtualRouterRef(entry, context);
+  });
+  return retVal;
+}, "de_VirtualRouterList");
+var de_VirtualRouterRef = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    meshName: import_smithy_client.expectString,
+    meshOwner: import_smithy_client.expectString,
+    resourceOwner: import_smithy_client.expectString,
+    version: import_smithy_client.expectLong,
+    virtualRouterName: import_smithy_client.expectString
+  });
+}, "de_VirtualRouterRef");
+var de_VirtualServiceData = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    meshName: import_smithy_client.expectString,
+    metadata: (_) => de_ResourceMetadata(_, context),
+    spec: import_smithy_client._json,
+    status: import_smithy_client._json,
+    virtualServiceName: import_smithy_client.expectString
+  });
+}, "de_VirtualServiceData");
+var de_VirtualServiceList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_VirtualServiceRef(entry, context);
+  });
+  return retVal;
+}, "de_VirtualServiceList");
+var de_VirtualServiceRef = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    lastUpdatedAt: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    meshName: import_smithy_client.expectString,
+    meshOwner: import_smithy_client.expectString,
+    resourceOwner: import_smithy_client.expectString,
+    version: import_smithy_client.expectLong,
+    virtualServiceName: import_smithy_client.expectString
+  });
+}, "de_VirtualServiceRef");
+var deserializeMetadata = /* @__PURE__ */ __name((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"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var _l = "limit";
+var _mO = "meshOwner";
+var _nT = "nextToken";
+var _rA = "resourceArn";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((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;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CreateGatewayRouteCommand.ts
+var _CreateGatewayRouteCommand = class _CreateGatewayRouteCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "CreateGatewayRoute", {}).n("AppMeshClient", "CreateGatewayRouteCommand").f(void 0, void 0).ser(se_CreateGatewayRouteCommand).de(de_CreateGatewayRouteCommand).build() {
+};
+__name(_CreateGatewayRouteCommand, "CreateGatewayRouteCommand");
+var CreateGatewayRouteCommand = _CreateGatewayRouteCommand;
+
+// src/commands/CreateMeshCommand.ts
+
+
+
+
+var _CreateMeshCommand = class _CreateMeshCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "CreateMesh", {}).n("AppMeshClient", "CreateMeshCommand").f(void 0, void 0).ser(se_CreateMeshCommand).de(de_CreateMeshCommand).build() {
+};
+__name(_CreateMeshCommand, "CreateMeshCommand");
+var CreateMeshCommand = _CreateMeshCommand;
+
+// src/commands/CreateRouteCommand.ts
+
+
+
+
+var _CreateRouteCommand = class _CreateRouteCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "CreateRoute", {}).n("AppMeshClient", "CreateRouteCommand").f(void 0, void 0).ser(se_CreateRouteCommand).de(de_CreateRouteCommand).build() {
+};
+__name(_CreateRouteCommand, "CreateRouteCommand");
+var CreateRouteCommand = _CreateRouteCommand;
+
+// src/commands/CreateVirtualGatewayCommand.ts
+
+
+
+
+var _CreateVirtualGatewayCommand = class _CreateVirtualGatewayCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "CreateVirtualGateway", {}).n("AppMeshClient", "CreateVirtualGatewayCommand").f(void 0, void 0).ser(se_CreateVirtualGatewayCommand).de(de_CreateVirtualGatewayCommand).build() {
+};
+__name(_CreateVirtualGatewayCommand, "CreateVirtualGatewayCommand");
+var CreateVirtualGatewayCommand = _CreateVirtualGatewayCommand;
+
+// src/commands/CreateVirtualNodeCommand.ts
+
+
+
+
+var _CreateVirtualNodeCommand = class _CreateVirtualNodeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "CreateVirtualNode", {}).n("AppMeshClient", "CreateVirtualNodeCommand").f(void 0, void 0).ser(se_CreateVirtualNodeCommand).de(de_CreateVirtualNodeCommand).build() {
+};
+__name(_CreateVirtualNodeCommand, "CreateVirtualNodeCommand");
+var CreateVirtualNodeCommand = _CreateVirtualNodeCommand;
+
+// src/commands/CreateVirtualRouterCommand.ts
+
+
+
+
+var _CreateVirtualRouterCommand = class _CreateVirtualRouterCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "CreateVirtualRouter", {}).n("AppMeshClient", "CreateVirtualRouterCommand").f(void 0, void 0).ser(se_CreateVirtualRouterCommand).de(de_CreateVirtualRouterCommand).build() {
+};
+__name(_CreateVirtualRouterCommand, "CreateVirtualRouterCommand");
+var CreateVirtualRouterCommand = _CreateVirtualRouterCommand;
+
+// src/commands/CreateVirtualServiceCommand.ts
+
+
+
+
+var _CreateVirtualServiceCommand = class _CreateVirtualServiceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "CreateVirtualService", {}).n("AppMeshClient", "CreateVirtualServiceCommand").f(void 0, void 0).ser(se_CreateVirtualServiceCommand).de(de_CreateVirtualServiceCommand).build() {
+};
+__name(_CreateVirtualServiceCommand, "CreateVirtualServiceCommand");
+var CreateVirtualServiceCommand = _CreateVirtualServiceCommand;
+
+// src/commands/DeleteGatewayRouteCommand.ts
+
+
+
+
+var _DeleteGatewayRouteCommand = class _DeleteGatewayRouteCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DeleteGatewayRoute", {}).n("AppMeshClient", "DeleteGatewayRouteCommand").f(void 0, void 0).ser(se_DeleteGatewayRouteCommand).de(de_DeleteGatewayRouteCommand).build() {
+};
+__name(_DeleteGatewayRouteCommand, "DeleteGatewayRouteCommand");
+var DeleteGatewayRouteCommand = _DeleteGatewayRouteCommand;
+
+// src/commands/DeleteMeshCommand.ts
+
+
+
+
+var _DeleteMeshCommand = class _DeleteMeshCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DeleteMesh", {}).n("AppMeshClient", "DeleteMeshCommand").f(void 0, void 0).ser(se_DeleteMeshCommand).de(de_DeleteMeshCommand).build() {
+};
+__name(_DeleteMeshCommand, "DeleteMeshCommand");
+var DeleteMeshCommand = _DeleteMeshCommand;
+
+// src/commands/DeleteRouteCommand.ts
+
+
+
+
+var _DeleteRouteCommand = class _DeleteRouteCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DeleteRoute", {}).n("AppMeshClient", "DeleteRouteCommand").f(void 0, void 0).ser(se_DeleteRouteCommand).de(de_DeleteRouteCommand).build() {
+};
+__name(_DeleteRouteCommand, "DeleteRouteCommand");
+var DeleteRouteCommand = _DeleteRouteCommand;
+
+// src/commands/DeleteVirtualGatewayCommand.ts
+
+
+
+
+var _DeleteVirtualGatewayCommand = class _DeleteVirtualGatewayCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DeleteVirtualGateway", {}).n("AppMeshClient", "DeleteVirtualGatewayCommand").f(void 0, void 0).ser(se_DeleteVirtualGatewayCommand).de(de_DeleteVirtualGatewayCommand).build() {
+};
+__name(_DeleteVirtualGatewayCommand, "DeleteVirtualGatewayCommand");
+var DeleteVirtualGatewayCommand = _DeleteVirtualGatewayCommand;
+
+// src/commands/DeleteVirtualNodeCommand.ts
+
+
+
+
+var _DeleteVirtualNodeCommand = class _DeleteVirtualNodeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DeleteVirtualNode", {}).n("AppMeshClient", "DeleteVirtualNodeCommand").f(void 0, void 0).ser(se_DeleteVirtualNodeCommand).de(de_DeleteVirtualNodeCommand).build() {
+};
+__name(_DeleteVirtualNodeCommand, "DeleteVirtualNodeCommand");
+var DeleteVirtualNodeCommand = _DeleteVirtualNodeCommand;
+
+// src/commands/DeleteVirtualRouterCommand.ts
+
+
+
+
+var _DeleteVirtualRouterCommand = class _DeleteVirtualRouterCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DeleteVirtualRouter", {}).n("AppMeshClient", "DeleteVirtualRouterCommand").f(void 0, void 0).ser(se_DeleteVirtualRouterCommand).de(de_DeleteVirtualRouterCommand).build() {
+};
+__name(_DeleteVirtualRouterCommand, "DeleteVirtualRouterCommand");
+var DeleteVirtualRouterCommand = _DeleteVirtualRouterCommand;
+
+// src/commands/DeleteVirtualServiceCommand.ts
+
+
+
+
+var _DeleteVirtualServiceCommand = class _DeleteVirtualServiceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DeleteVirtualService", {}).n("AppMeshClient", "DeleteVirtualServiceCommand").f(void 0, void 0).ser(se_DeleteVirtualServiceCommand).de(de_DeleteVirtualServiceCommand).build() {
+};
+__name(_DeleteVirtualServiceCommand, "DeleteVirtualServiceCommand");
+var DeleteVirtualServiceCommand = _DeleteVirtualServiceCommand;
+
+// src/commands/DescribeGatewayRouteCommand.ts
+
+
+
+
+var _DescribeGatewayRouteCommand = class _DescribeGatewayRouteCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DescribeGatewayRoute", {}).n("AppMeshClient", "DescribeGatewayRouteCommand").f(void 0, void 0).ser(se_DescribeGatewayRouteCommand).de(de_DescribeGatewayRouteCommand).build() {
+};
+__name(_DescribeGatewayRouteCommand, "DescribeGatewayRouteCommand");
+var DescribeGatewayRouteCommand = _DescribeGatewayRouteCommand;
+
+// src/commands/DescribeMeshCommand.ts
+
+
+
+
+var _DescribeMeshCommand = class _DescribeMeshCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DescribeMesh", {}).n("AppMeshClient", "DescribeMeshCommand").f(void 0, void 0).ser(se_DescribeMeshCommand).de(de_DescribeMeshCommand).build() {
+};
+__name(_DescribeMeshCommand, "DescribeMeshCommand");
+var DescribeMeshCommand = _DescribeMeshCommand;
+
+// src/commands/DescribeRouteCommand.ts
+
+
+
+
+var _DescribeRouteCommand = class _DescribeRouteCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DescribeRoute", {}).n("AppMeshClient", "DescribeRouteCommand").f(void 0, void 0).ser(se_DescribeRouteCommand).de(de_DescribeRouteCommand).build() {
+};
+__name(_DescribeRouteCommand, "DescribeRouteCommand");
+var DescribeRouteCommand = _DescribeRouteCommand;
+
+// src/commands/DescribeVirtualGatewayCommand.ts
+
+
+
+
+var _DescribeVirtualGatewayCommand = class _DescribeVirtualGatewayCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DescribeVirtualGateway", {}).n("AppMeshClient", "DescribeVirtualGatewayCommand").f(void 0, void 0).ser(se_DescribeVirtualGatewayCommand).de(de_DescribeVirtualGatewayCommand).build() {
+};
+__name(_DescribeVirtualGatewayCommand, "DescribeVirtualGatewayCommand");
+var DescribeVirtualGatewayCommand = _DescribeVirtualGatewayCommand;
+
+// src/commands/DescribeVirtualNodeCommand.ts
+
+
+
+
+var _DescribeVirtualNodeCommand = class _DescribeVirtualNodeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DescribeVirtualNode", {}).n("AppMeshClient", "DescribeVirtualNodeCommand").f(void 0, void 0).ser(se_DescribeVirtualNodeCommand).de(de_DescribeVirtualNodeCommand).build() {
+};
+__name(_DescribeVirtualNodeCommand, "DescribeVirtualNodeCommand");
+var DescribeVirtualNodeCommand = _DescribeVirtualNodeCommand;
+
+// src/commands/DescribeVirtualRouterCommand.ts
+
+
+
+
+var _DescribeVirtualRouterCommand = class _DescribeVirtualRouterCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DescribeVirtualRouter", {}).n("AppMeshClient", "DescribeVirtualRouterCommand").f(void 0, void 0).ser(se_DescribeVirtualRouterCommand).de(de_DescribeVirtualRouterCommand).build() {
+};
+__name(_DescribeVirtualRouterCommand, "DescribeVirtualRouterCommand");
+var DescribeVirtualRouterCommand = _DescribeVirtualRouterCommand;
+
+// src/commands/DescribeVirtualServiceCommand.ts
+
+
+
+
+var _DescribeVirtualServiceCommand = class _DescribeVirtualServiceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "DescribeVirtualService", {}).n("AppMeshClient", "DescribeVirtualServiceCommand").f(void 0, void 0).ser(se_DescribeVirtualServiceCommand).de(de_DescribeVirtualServiceCommand).build() {
+};
+__name(_DescribeVirtualServiceCommand, "DescribeVirtualServiceCommand");
+var DescribeVirtualServiceCommand = _DescribeVirtualServiceCommand;
+
+// src/commands/ListGatewayRoutesCommand.ts
+
+
+
+
+var _ListGatewayRoutesCommand = class _ListGatewayRoutesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "ListGatewayRoutes", {}).n("AppMeshClient", "ListGatewayRoutesCommand").f(void 0, void 0).ser(se_ListGatewayRoutesCommand).de(de_ListGatewayRoutesCommand).build() {
+};
+__name(_ListGatewayRoutesCommand, "ListGatewayRoutesCommand");
+var ListGatewayRoutesCommand = _ListGatewayRoutesCommand;
+
+// src/commands/ListMeshesCommand.ts
+
+
+
+
+var _ListMeshesCommand = class _ListMeshesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "ListMeshes", {}).n("AppMeshClient", "ListMeshesCommand").f(void 0, void 0).ser(se_ListMeshesCommand).de(de_ListMeshesCommand).build() {
+};
+__name(_ListMeshesCommand, "ListMeshesCommand");
+var ListMeshesCommand = _ListMeshesCommand;
+
+// src/commands/ListRoutesCommand.ts
+
+
+
+
+var _ListRoutesCommand = class _ListRoutesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "ListRoutes", {}).n("AppMeshClient", "ListRoutesCommand").f(void 0, void 0).ser(se_ListRoutesCommand).de(de_ListRoutesCommand).build() {
+};
+__name(_ListRoutesCommand, "ListRoutesCommand");
+var ListRoutesCommand = _ListRoutesCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "ListTagsForResource", {}).n("AppMeshClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ListVirtualGatewaysCommand.ts
+
+
+
+
+var _ListVirtualGatewaysCommand = class _ListVirtualGatewaysCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "ListVirtualGateways", {}).n("AppMeshClient", "ListVirtualGatewaysCommand").f(void 0, void 0).ser(se_ListVirtualGatewaysCommand).de(de_ListVirtualGatewaysCommand).build() {
+};
+__name(_ListVirtualGatewaysCommand, "ListVirtualGatewaysCommand");
+var ListVirtualGatewaysCommand = _ListVirtualGatewaysCommand;
+
+// src/commands/ListVirtualNodesCommand.ts
+
+
+
+
+var _ListVirtualNodesCommand = class _ListVirtualNodesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "ListVirtualNodes", {}).n("AppMeshClient", "ListVirtualNodesCommand").f(void 0, void 0).ser(se_ListVirtualNodesCommand).de(de_ListVirtualNodesCommand).build() {
+};
+__name(_ListVirtualNodesCommand, "ListVirtualNodesCommand");
+var ListVirtualNodesCommand = _ListVirtualNodesCommand;
+
+// src/commands/ListVirtualRoutersCommand.ts
+
+
+
+
+var _ListVirtualRoutersCommand = class _ListVirtualRoutersCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "ListVirtualRouters", {}).n("AppMeshClient", "ListVirtualRoutersCommand").f(void 0, void 0).ser(se_ListVirtualRoutersCommand).de(de_ListVirtualRoutersCommand).build() {
+};
+__name(_ListVirtualRoutersCommand, "ListVirtualRoutersCommand");
+var ListVirtualRoutersCommand = _ListVirtualRoutersCommand;
+
+// src/commands/ListVirtualServicesCommand.ts
+
+
+
+
+var _ListVirtualServicesCommand = class _ListVirtualServicesCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "ListVirtualServices", {}).n("AppMeshClient", "ListVirtualServicesCommand").f(void 0, void 0).ser(se_ListVirtualServicesCommand).de(de_ListVirtualServicesCommand).build() {
+};
+__name(_ListVirtualServicesCommand, "ListVirtualServicesCommand");
+var ListVirtualServicesCommand = _ListVirtualServicesCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "TagResource", {}).n("AppMeshClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "UntagResource", {}).n("AppMeshClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateGatewayRouteCommand.ts
+
+
+
+
+var _UpdateGatewayRouteCommand = class _UpdateGatewayRouteCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "UpdateGatewayRoute", {}).n("AppMeshClient", "UpdateGatewayRouteCommand").f(void 0, void 0).ser(se_UpdateGatewayRouteCommand).de(de_UpdateGatewayRouteCommand).build() {
+};
+__name(_UpdateGatewayRouteCommand, "UpdateGatewayRouteCommand");
+var UpdateGatewayRouteCommand = _UpdateGatewayRouteCommand;
+
+// src/commands/UpdateMeshCommand.ts
+
+
+
+
+var _UpdateMeshCommand = class _UpdateMeshCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "UpdateMesh", {}).n("AppMeshClient", "UpdateMeshCommand").f(void 0, void 0).ser(se_UpdateMeshCommand).de(de_UpdateMeshCommand).build() {
+};
+__name(_UpdateMeshCommand, "UpdateMeshCommand");
+var UpdateMeshCommand = _UpdateMeshCommand;
+
+// src/commands/UpdateRouteCommand.ts
+
+
+
+
+var _UpdateRouteCommand = class _UpdateRouteCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "UpdateRoute", {}).n("AppMeshClient", "UpdateRouteCommand").f(void 0, void 0).ser(se_UpdateRouteCommand).de(de_UpdateRouteCommand).build() {
+};
+__name(_UpdateRouteCommand, "UpdateRouteCommand");
+var UpdateRouteCommand = _UpdateRouteCommand;
+
+// src/commands/UpdateVirtualGatewayCommand.ts
+
+
+
+
+var _UpdateVirtualGatewayCommand = class _UpdateVirtualGatewayCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "UpdateVirtualGateway", {}).n("AppMeshClient", "UpdateVirtualGatewayCommand").f(void 0, void 0).ser(se_UpdateVirtualGatewayCommand).de(de_UpdateVirtualGatewayCommand).build() {
+};
+__name(_UpdateVirtualGatewayCommand, "UpdateVirtualGatewayCommand");
+var UpdateVirtualGatewayCommand = _UpdateVirtualGatewayCommand;
+
+// src/commands/UpdateVirtualNodeCommand.ts
+
+
+
+
+var _UpdateVirtualNodeCommand = class _UpdateVirtualNodeCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "UpdateVirtualNode", {}).n("AppMeshClient", "UpdateVirtualNodeCommand").f(void 0, void 0).ser(se_UpdateVirtualNodeCommand).de(de_UpdateVirtualNodeCommand).build() {
+};
+__name(_UpdateVirtualNodeCommand, "UpdateVirtualNodeCommand");
+var UpdateVirtualNodeCommand = _UpdateVirtualNodeCommand;
+
+// src/commands/UpdateVirtualRouterCommand.ts
+
+
+
+
+var _UpdateVirtualRouterCommand = class _UpdateVirtualRouterCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "UpdateVirtualRouter", {}).n("AppMeshClient", "UpdateVirtualRouterCommand").f(void 0, void 0).ser(se_UpdateVirtualRouterCommand).de(de_UpdateVirtualRouterCommand).build() {
+};
+__name(_UpdateVirtualRouterCommand, "UpdateVirtualRouterCommand");
+var UpdateVirtualRouterCommand = _UpdateVirtualRouterCommand;
+
+// src/commands/UpdateVirtualServiceCommand.ts
+
+
+
+
+var _UpdateVirtualServiceCommand = class _UpdateVirtualServiceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AppMesh", "UpdateVirtualService", {}).n("AppMeshClient", "UpdateVirtualServiceCommand").f(void 0, void 0).ser(se_UpdateVirtualServiceCommand).de(de_UpdateVirtualServiceCommand).build() {
+};
+__name(_UpdateVirtualServiceCommand, "UpdateVirtualServiceCommand");
+var UpdateVirtualServiceCommand = _UpdateVirtualServiceCommand;
+
+// src/AppMesh.ts
+var commands = {
+  CreateGatewayRouteCommand,
+  CreateMeshCommand,
+  CreateRouteCommand,
+  CreateVirtualGatewayCommand,
+  CreateVirtualNodeCommand,
+  CreateVirtualRouterCommand,
+  CreateVirtualServiceCommand,
+  DeleteGatewayRouteCommand,
+  DeleteMeshCommand,
+  DeleteRouteCommand,
+  DeleteVirtualGatewayCommand,
+  DeleteVirtualNodeCommand,
+  DeleteVirtualRouterCommand,
+  DeleteVirtualServiceCommand,
+  DescribeGatewayRouteCommand,
+  DescribeMeshCommand,
+  DescribeRouteCommand,
+  DescribeVirtualGatewayCommand,
+  DescribeVirtualNodeCommand,
+  DescribeVirtualRouterCommand,
+  DescribeVirtualServiceCommand,
+  ListGatewayRoutesCommand,
+  ListMeshesCommand,
+  ListRoutesCommand,
+  ListTagsForResourceCommand,
+  ListVirtualGatewaysCommand,
+  ListVirtualNodesCommand,
+  ListVirtualRoutersCommand,
+  ListVirtualServicesCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateGatewayRouteCommand,
+  UpdateMeshCommand,
+  UpdateRouteCommand,
+  UpdateVirtualGatewayCommand,
+  UpdateVirtualNodeCommand,
+  UpdateVirtualRouterCommand,
+  UpdateVirtualServiceCommand
+};
+var _AppMesh = class _AppMesh extends AppMeshClient {
+};
+__name(_AppMesh, "AppMesh");
+var AppMesh = _AppMesh;
+(0, import_smithy_client.createAggregatedClient)(commands, AppMesh);
+
+// src/pagination/ListGatewayRoutesPaginator.ts
+
+var paginateListGatewayRoutes = (0, import_core.createPaginator)(AppMeshClient, ListGatewayRoutesCommand, "nextToken", "nextToken", "limit");
+
+// src/pagination/ListMeshesPaginator.ts
+
+var paginateListMeshes = (0, import_core.createPaginator)(AppMeshClient, ListMeshesCommand, "nextToken", "nextToken", "limit");
+
+// src/pagination/ListRoutesPaginator.ts
+
+var paginateListRoutes = (0, import_core.createPaginator)(AppMeshClient, ListRoutesCommand, "nextToken", "nextToken", "limit");
+
+// src/pagination/ListTagsForResourcePaginator.ts
+
+var paginateListTagsForResource = (0, import_core.createPaginator)(AppMeshClient, ListTagsForResourceCommand, "nextToken", "nextToken", "limit");
+
+// src/pagination/ListVirtualGatewaysPaginator.ts
+
+var paginateListVirtualGateways = (0, import_core.createPaginator)(AppMeshClient, ListVirtualGatewaysCommand, "nextToken", "nextToken", "limit");
+
+// src/pagination/ListVirtualNodesPaginator.ts
+
+var paginateListVirtualNodes = (0, import_core.createPaginator)(AppMeshClient, ListVirtualNodesCommand, "nextToken", "nextToken", "limit");
+
+// src/pagination/ListVirtualRoutersPaginator.ts
+
+var paginateListVirtualRouters = (0, import_core.createPaginator)(AppMeshClient, ListVirtualRoutersCommand, "nextToken", "nextToken", "limit");
+
+// src/pagination/ListVirtualServicesPaginator.ts
+
+var paginateListVirtualServices = (0, import_core.createPaginator)(AppMeshClient, ListVirtualServicesCommand, "nextToken", "nextToken", "limit");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+
+0 && (module.exports = {
+  AccessLog,
+  AppMesh,
+  AppMeshClient,
+  AppMeshServiceException,
+  Backend,
+  BadRequestException,
+  ClientTlsCertificate,
+  ConflictException,
+  CreateGatewayRouteCommand,
+  CreateMeshCommand,
+  CreateRouteCommand,
+  CreateVirtualGatewayCommand,
+  CreateVirtualNodeCommand,
+  CreateVirtualRouterCommand,
+  CreateVirtualServiceCommand,
+  DefaultGatewayRouteRewrite,
+  DeleteGatewayRouteCommand,
+  DeleteMeshCommand,
+  DeleteRouteCommand,
+  DeleteVirtualGatewayCommand,
+  DeleteVirtualNodeCommand,
+  DeleteVirtualRouterCommand,
+  DeleteVirtualServiceCommand,
+  DescribeGatewayRouteCommand,
+  DescribeMeshCommand,
+  DescribeRouteCommand,
+  DescribeVirtualGatewayCommand,
+  DescribeVirtualNodeCommand,
+  DescribeVirtualRouterCommand,
+  DescribeVirtualServiceCommand,
+  DnsResponseType,
+  DurationUnit,
+  EgressFilterType,
+  ForbiddenException,
+  GatewayRouteStatusCode,
+  GrpcMetadataMatchMethod,
+  GrpcRetryPolicyEvent,
+  GrpcRouteMetadataMatchMethod,
+  HeaderMatchMethod,
+  HttpMethod,
+  HttpScheme,
+  InternalServerErrorException,
+  IpPreference,
+  LimitExceededException,
+  ListGatewayRoutesCommand,
+  ListMeshesCommand,
+  ListRoutesCommand,
+  ListTagsForResourceCommand,
+  ListVirtualGatewaysCommand,
+  ListVirtualNodesCommand,
+  ListVirtualRoutersCommand,
+  ListVirtualServicesCommand,
+  ListenerTimeout,
+  ListenerTlsCertificate,
+  ListenerTlsMode,
+  ListenerTlsValidationContextTrust,
+  LoggingFormat,
+  MeshStatusCode,
+  NotFoundException,
+  PortProtocol,
+  ResourceInUseException,
+  RouteStatusCode,
+  ServiceDiscovery,
+  ServiceUnavailableException,
+  TagResourceCommand,
+  TcpRetryPolicyEvent,
+  TlsValidationContextTrust,
+  TooManyRequestsException,
+  TooManyTagsException,
+  UntagResourceCommand,
+  UpdateGatewayRouteCommand,
+  UpdateMeshCommand,
+  UpdateRouteCommand,
+  UpdateVirtualGatewayCommand,
+  UpdateVirtualNodeCommand,
+  UpdateVirtualRouterCommand,
+  UpdateVirtualServiceCommand,
+  VirtualGatewayAccessLog,
+  VirtualGatewayClientTlsCertificate,
+  VirtualGatewayConnectionPool,
+  VirtualGatewayListenerTlsCertificate,
+  VirtualGatewayListenerTlsMode,
+  VirtualGatewayListenerTlsValidationContextTrust,
+  VirtualGatewayPortProtocol,
+  VirtualGatewayStatusCode,
+  VirtualGatewayTlsValidationContextTrust,
+  VirtualNodeConnectionPool,
+  VirtualNodeStatusCode,
+  VirtualRouterStatusCode,
+  VirtualServiceProvider,
+  VirtualServiceStatusCode,
+  __Client,
+  paginateListGatewayRoutes,
+  paginateListMeshes,
+  paginateListRoutes,
+  paginateListTagsForResource,
+  paginateListVirtualGateways,
+  paginateListVirtualNodes,
+  paginateListVirtualRouters,
+  paginateListVirtualServices
+});
+