@aws-sdk/client-direct-connect 3.489.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,11 +1,4537 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DirectConnectServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./DirectConnectClient"), exports);
-tslib_1.__exportStar(require("./DirectConnect"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var DirectConnectServiceException_1 = require("./models/DirectConnectServiceException");
-Object.defineProperty(exports, "DirectConnectServiceException", { enumerable: true, get: function () { return DirectConnectServiceException_1.DirectConnectServiceException; } });
+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, {
+  AcceptDirectConnectGatewayAssociationProposalCommand: () => AcceptDirectConnectGatewayAssociationProposalCommand,
+  AddressFamily: () => AddressFamily,
+  AllocateConnectionOnInterconnectCommand: () => AllocateConnectionOnInterconnectCommand,
+  AllocateHostedConnectionCommand: () => AllocateHostedConnectionCommand,
+  AllocatePrivateVirtualInterfaceCommand: () => AllocatePrivateVirtualInterfaceCommand,
+  AllocatePublicVirtualInterfaceCommand: () => AllocatePublicVirtualInterfaceCommand,
+  AllocateTransitVirtualInterfaceCommand: () => AllocateTransitVirtualInterfaceCommand,
+  AssociateConnectionWithLagCommand: () => AssociateConnectionWithLagCommand,
+  AssociateHostedConnectionCommand: () => AssociateHostedConnectionCommand,
+  AssociateMacSecKeyCommand: () => AssociateMacSecKeyCommand,
+  AssociateVirtualInterfaceCommand: () => AssociateVirtualInterfaceCommand,
+  BGPPeerState: () => BGPPeerState,
+  BGPStatus: () => BGPStatus,
+  ConfirmConnectionCommand: () => ConfirmConnectionCommand,
+  ConfirmCustomerAgreementCommand: () => ConfirmCustomerAgreementCommand,
+  ConfirmPrivateVirtualInterfaceCommand: () => ConfirmPrivateVirtualInterfaceCommand,
+  ConfirmPublicVirtualInterfaceCommand: () => ConfirmPublicVirtualInterfaceCommand,
+  ConfirmTransitVirtualInterfaceCommand: () => ConfirmTransitVirtualInterfaceCommand,
+  ConnectionState: () => ConnectionState,
+  CreateBGPPeerCommand: () => CreateBGPPeerCommand,
+  CreateConnectionCommand: () => CreateConnectionCommand,
+  CreateDirectConnectGatewayAssociationCommand: () => CreateDirectConnectGatewayAssociationCommand,
+  CreateDirectConnectGatewayAssociationProposalCommand: () => CreateDirectConnectGatewayAssociationProposalCommand,
+  CreateDirectConnectGatewayCommand: () => CreateDirectConnectGatewayCommand,
+  CreateInterconnectCommand: () => CreateInterconnectCommand,
+  CreateLagCommand: () => CreateLagCommand,
+  CreatePrivateVirtualInterfaceCommand: () => CreatePrivateVirtualInterfaceCommand,
+  CreatePublicVirtualInterfaceCommand: () => CreatePublicVirtualInterfaceCommand,
+  CreateTransitVirtualInterfaceCommand: () => CreateTransitVirtualInterfaceCommand,
+  DeleteBGPPeerCommand: () => DeleteBGPPeerCommand,
+  DeleteConnectionCommand: () => DeleteConnectionCommand,
+  DeleteDirectConnectGatewayAssociationCommand: () => DeleteDirectConnectGatewayAssociationCommand,
+  DeleteDirectConnectGatewayAssociationProposalCommand: () => DeleteDirectConnectGatewayAssociationProposalCommand,
+  DeleteDirectConnectGatewayCommand: () => DeleteDirectConnectGatewayCommand,
+  DeleteInterconnectCommand: () => DeleteInterconnectCommand,
+  DeleteLagCommand: () => DeleteLagCommand,
+  DeleteVirtualInterfaceCommand: () => DeleteVirtualInterfaceCommand,
+  DescribeConnectionLoaCommand: () => DescribeConnectionLoaCommand,
+  DescribeConnectionsCommand: () => DescribeConnectionsCommand,
+  DescribeConnectionsOnInterconnectCommand: () => DescribeConnectionsOnInterconnectCommand,
+  DescribeCustomerMetadataCommand: () => DescribeCustomerMetadataCommand,
+  DescribeDirectConnectGatewayAssociationProposalsCommand: () => DescribeDirectConnectGatewayAssociationProposalsCommand,
+  DescribeDirectConnectGatewayAssociationsCommand: () => DescribeDirectConnectGatewayAssociationsCommand,
+  DescribeDirectConnectGatewayAttachmentsCommand: () => DescribeDirectConnectGatewayAttachmentsCommand,
+  DescribeDirectConnectGatewaysCommand: () => DescribeDirectConnectGatewaysCommand,
+  DescribeHostedConnectionsCommand: () => DescribeHostedConnectionsCommand,
+  DescribeInterconnectLoaCommand: () => DescribeInterconnectLoaCommand,
+  DescribeInterconnectsCommand: () => DescribeInterconnectsCommand,
+  DescribeLagsCommand: () => DescribeLagsCommand,
+  DescribeLoaCommand: () => DescribeLoaCommand,
+  DescribeLocationsCommand: () => DescribeLocationsCommand,
+  DescribeRouterConfigurationCommand: () => DescribeRouterConfigurationCommand,
+  DescribeTagsCommand: () => DescribeTagsCommand,
+  DescribeVirtualGatewaysCommand: () => DescribeVirtualGatewaysCommand,
+  DescribeVirtualInterfacesCommand: () => DescribeVirtualInterfacesCommand,
+  DirectConnect: () => DirectConnect,
+  DirectConnectClient: () => DirectConnectClient,
+  DirectConnectClientException: () => DirectConnectClientException,
+  DirectConnectGatewayAssociationProposalState: () => DirectConnectGatewayAssociationProposalState,
+  DirectConnectGatewayAssociationState: () => DirectConnectGatewayAssociationState,
+  DirectConnectGatewayAttachmentState: () => DirectConnectGatewayAttachmentState,
+  DirectConnectGatewayAttachmentType: () => DirectConnectGatewayAttachmentType,
+  DirectConnectGatewayState: () => DirectConnectGatewayState,
+  DirectConnectServerException: () => DirectConnectServerException,
+  DirectConnectServiceException: () => DirectConnectServiceException,
+  DisassociateConnectionFromLagCommand: () => DisassociateConnectionFromLagCommand,
+  DisassociateMacSecKeyCommand: () => DisassociateMacSecKeyCommand,
+  DuplicateTagKeysException: () => DuplicateTagKeysException,
+  GatewayType: () => GatewayType,
+  HasLogicalRedundancy: () => HasLogicalRedundancy,
+  InterconnectState: () => InterconnectState,
+  LagState: () => LagState,
+  ListVirtualInterfaceTestHistoryCommand: () => ListVirtualInterfaceTestHistoryCommand,
+  LoaContentType: () => LoaContentType,
+  NniPartnerType: () => NniPartnerType,
+  StartBgpFailoverTestCommand: () => StartBgpFailoverTestCommand,
+  StopBgpFailoverTestCommand: () => StopBgpFailoverTestCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  TooManyTagsException: () => TooManyTagsException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateConnectionCommand: () => UpdateConnectionCommand,
+  UpdateDirectConnectGatewayAssociationCommand: () => UpdateDirectConnectGatewayAssociationCommand,
+  UpdateDirectConnectGatewayCommand: () => UpdateDirectConnectGatewayCommand,
+  UpdateLagCommand: () => UpdateLagCommand,
+  UpdateVirtualInterfaceAttributesCommand: () => UpdateVirtualInterfaceAttributesCommand,
+  VirtualInterfaceState: () => VirtualInterfaceState,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/DirectConnectClient.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: "directconnect"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/DirectConnectClient.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/DirectConnectClient.ts
+var _DirectConnectClient = class _DirectConnectClient 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(_DirectConnectClient, "DirectConnectClient");
+var DirectConnectClient = _DirectConnectClient;
+
+// src/DirectConnect.ts
+
+
+// src/commands/AcceptDirectConnectGatewayAssociationProposalCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/DirectConnectServiceException.ts
+
+var _DirectConnectServiceException = class _DirectConnectServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _DirectConnectServiceException.prototype);
+  }
+};
+__name(_DirectConnectServiceException, "DirectConnectServiceException");
+var DirectConnectServiceException = _DirectConnectServiceException;
+
+// src/models/models_0.ts
+var GatewayType = {
+  TransitGateway: "transitGateway",
+  VirtualPrivateGateway: "virtualPrivateGateway"
+};
+var DirectConnectGatewayAssociationState = {
+  associated: "associated",
+  associating: "associating",
+  disassociated: "disassociated",
+  disassociating: "disassociating",
+  updating: "updating"
+};
+var _DirectConnectClientException = class _DirectConnectClientException extends DirectConnectServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DirectConnectClientException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DirectConnectClientException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DirectConnectClientException.prototype);
+  }
+};
+__name(_DirectConnectClientException, "DirectConnectClientException");
+var DirectConnectClientException = _DirectConnectClientException;
+var _DirectConnectServerException = class _DirectConnectServerException extends DirectConnectServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DirectConnectServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "DirectConnectServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _DirectConnectServerException.prototype);
+  }
+};
+__name(_DirectConnectServerException, "DirectConnectServerException");
+var DirectConnectServerException = _DirectConnectServerException;
+var AddressFamily = {
+  IPv4: "ipv4",
+  IPv6: "ipv6"
+};
+var ConnectionState = {
+  available: "available",
+  deleted: "deleted",
+  deleting: "deleting",
+  down: "down",
+  ordering: "ordering",
+  pending: "pending",
+  rejected: "rejected",
+  requested: "requested",
+  unknown: "unknown"
+};
+var HasLogicalRedundancy = {
+  No: "no",
+  Unknown: "unknown",
+  Yes: "yes"
+};
+var _DuplicateTagKeysException = class _DuplicateTagKeysException extends DirectConnectServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DuplicateTagKeysException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DuplicateTagKeysException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DuplicateTagKeysException.prototype);
+  }
+};
+__name(_DuplicateTagKeysException, "DuplicateTagKeysException");
+var DuplicateTagKeysException = _DuplicateTagKeysException;
+var _TooManyTagsException = class _TooManyTagsException extends DirectConnectServiceException {
+  /**
+   * @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;
+var BGPPeerState = {
+  Available: "available",
+  Deleted: "deleted",
+  Deleting: "deleting",
+  Pending: "pending",
+  Verifying: "verifying"
+};
+var BGPStatus = {
+  Down: "down",
+  Unknown: "unknown",
+  Up: "up"
+};
+var VirtualInterfaceState = {
+  available: "available",
+  confirming: "confirming",
+  deleted: "deleted",
+  deleting: "deleting",
+  down: "down",
+  pending: "pending",
+  rejected: "rejected",
+  unknown: "unknown",
+  verifying: "verifying"
+};
+var DirectConnectGatewayState = {
+  available: "available",
+  deleted: "deleted",
+  deleting: "deleting",
+  pending: "pending"
+};
+var DirectConnectGatewayAssociationProposalState = {
+  accepted: "accepted",
+  deleted: "deleted",
+  requested: "requested"
+};
+var InterconnectState = {
+  available: "available",
+  deleted: "deleted",
+  deleting: "deleting",
+  down: "down",
+  pending: "pending",
+  requested: "requested",
+  unknown: "unknown"
+};
+var LagState = {
+  available: "available",
+  deleted: "deleted",
+  deleting: "deleting",
+  down: "down",
+  pending: "pending",
+  requested: "requested",
+  unknown: "unknown"
+};
+var LoaContentType = {
+  PDF: "application/pdf"
+};
+var NniPartnerType = {
+  NonPartner: "nonPartner",
+  V1: "v1",
+  V2: "v2"
+};
+var DirectConnectGatewayAttachmentState = {
+  attached: "attached",
+  attaching: "attaching",
+  detached: "detached",
+  detaching: "detaching"
+};
+var DirectConnectGatewayAttachmentType = {
+  PrivateVirtualInterface: "PrivateVirtualInterface",
+  TransitVirtualInterface: "TransitVirtualInterface"
+};
+
+// src/protocols/Aws_json1_1.ts
+var se_AcceptDirectConnectGatewayAssociationProposalCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AcceptDirectConnectGatewayAssociationProposal");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AcceptDirectConnectGatewayAssociationProposalCommand");
+var se_AllocateConnectionOnInterconnectCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AllocateConnectionOnInterconnect");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AllocateConnectionOnInterconnectCommand");
+var se_AllocateHostedConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AllocateHostedConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AllocateHostedConnectionCommand");
+var se_AllocatePrivateVirtualInterfaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AllocatePrivateVirtualInterface");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AllocatePrivateVirtualInterfaceCommand");
+var se_AllocatePublicVirtualInterfaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AllocatePublicVirtualInterface");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AllocatePublicVirtualInterfaceCommand");
+var se_AllocateTransitVirtualInterfaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AllocateTransitVirtualInterface");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AllocateTransitVirtualInterfaceCommand");
+var se_AssociateConnectionWithLagCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateConnectionWithLag");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateConnectionWithLagCommand");
+var se_AssociateHostedConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateHostedConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateHostedConnectionCommand");
+var se_AssociateMacSecKeyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateMacSecKey");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateMacSecKeyCommand");
+var se_AssociateVirtualInterfaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateVirtualInterface");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateVirtualInterfaceCommand");
+var se_ConfirmConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ConfirmConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ConfirmConnectionCommand");
+var se_ConfirmCustomerAgreementCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ConfirmCustomerAgreement");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ConfirmCustomerAgreementCommand");
+var se_ConfirmPrivateVirtualInterfaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ConfirmPrivateVirtualInterface");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ConfirmPrivateVirtualInterfaceCommand");
+var se_ConfirmPublicVirtualInterfaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ConfirmPublicVirtualInterface");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ConfirmPublicVirtualInterfaceCommand");
+var se_ConfirmTransitVirtualInterfaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ConfirmTransitVirtualInterface");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ConfirmTransitVirtualInterfaceCommand");
+var se_CreateBGPPeerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateBGPPeer");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateBGPPeerCommand");
+var se_CreateConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateConnectionCommand");
+var se_CreateDirectConnectGatewayCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateDirectConnectGateway");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateDirectConnectGatewayCommand");
+var se_CreateDirectConnectGatewayAssociationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateDirectConnectGatewayAssociation");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateDirectConnectGatewayAssociationCommand");
+var se_CreateDirectConnectGatewayAssociationProposalCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateDirectConnectGatewayAssociationProposal");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateDirectConnectGatewayAssociationProposalCommand");
+var se_CreateInterconnectCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateInterconnect");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateInterconnectCommand");
+var se_CreateLagCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateLag");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateLagCommand");
+var se_CreatePrivateVirtualInterfaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreatePrivateVirtualInterface");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreatePrivateVirtualInterfaceCommand");
+var se_CreatePublicVirtualInterfaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreatePublicVirtualInterface");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreatePublicVirtualInterfaceCommand");
+var se_CreateTransitVirtualInterfaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateTransitVirtualInterface");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateTransitVirtualInterfaceCommand");
+var se_DeleteBGPPeerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteBGPPeer");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteBGPPeerCommand");
+var se_DeleteConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteConnectionCommand");
+var se_DeleteDirectConnectGatewayCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteDirectConnectGateway");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteDirectConnectGatewayCommand");
+var se_DeleteDirectConnectGatewayAssociationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteDirectConnectGatewayAssociation");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteDirectConnectGatewayAssociationCommand");
+var se_DeleteDirectConnectGatewayAssociationProposalCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteDirectConnectGatewayAssociationProposal");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteDirectConnectGatewayAssociationProposalCommand");
+var se_DeleteInterconnectCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteInterconnect");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteInterconnectCommand");
+var se_DeleteLagCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteLag");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteLagCommand");
+var se_DeleteVirtualInterfaceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteVirtualInterface");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteVirtualInterfaceCommand");
+var se_DescribeConnectionLoaCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeConnectionLoa");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeConnectionLoaCommand");
+var se_DescribeConnectionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeConnections");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeConnectionsCommand");
+var se_DescribeConnectionsOnInterconnectCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeConnectionsOnInterconnect");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeConnectionsOnInterconnectCommand");
+var se_DescribeCustomerMetadataCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeCustomerMetadata");
+  const body = "{}";
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeCustomerMetadataCommand");
+var se_DescribeDirectConnectGatewayAssociationProposalsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeDirectConnectGatewayAssociationProposals");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeDirectConnectGatewayAssociationProposalsCommand");
+var se_DescribeDirectConnectGatewayAssociationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeDirectConnectGatewayAssociations");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeDirectConnectGatewayAssociationsCommand");
+var se_DescribeDirectConnectGatewayAttachmentsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeDirectConnectGatewayAttachments");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeDirectConnectGatewayAttachmentsCommand");
+var se_DescribeDirectConnectGatewaysCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeDirectConnectGateways");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeDirectConnectGatewaysCommand");
+var se_DescribeHostedConnectionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeHostedConnections");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeHostedConnectionsCommand");
+var se_DescribeInterconnectLoaCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeInterconnectLoa");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeInterconnectLoaCommand");
+var se_DescribeInterconnectsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeInterconnects");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeInterconnectsCommand");
+var se_DescribeLagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeLags");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeLagsCommand");
+var se_DescribeLoaCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeLoa");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeLoaCommand");
+var se_DescribeLocationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeLocations");
+  const body = "{}";
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeLocationsCommand");
+var se_DescribeRouterConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeRouterConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeRouterConfigurationCommand");
+var se_DescribeTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeTags");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeTagsCommand");
+var se_DescribeVirtualGatewaysCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeVirtualGateways");
+  const body = "{}";
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeVirtualGatewaysCommand");
+var se_DescribeVirtualInterfacesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeVirtualInterfaces");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeVirtualInterfacesCommand");
+var se_DisassociateConnectionFromLagCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DisassociateConnectionFromLag");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisassociateConnectionFromLagCommand");
+var se_DisassociateMacSecKeyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DisassociateMacSecKey");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisassociateMacSecKeyCommand");
+var se_ListVirtualInterfaceTestHistoryCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListVirtualInterfaceTestHistory");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListVirtualInterfaceTestHistoryCommand");
+var se_StartBgpFailoverTestCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StartBgpFailoverTest");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StartBgpFailoverTestCommand");
+var se_StopBgpFailoverTestCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("StopBgpFailoverTest");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_StopBgpFailoverTestCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagResourceCommand");
+var se_UpdateConnectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateConnection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateConnectionCommand");
+var se_UpdateDirectConnectGatewayCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateDirectConnectGateway");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateDirectConnectGatewayCommand");
+var se_UpdateDirectConnectGatewayAssociationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateDirectConnectGatewayAssociation");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateDirectConnectGatewayAssociationCommand");
+var se_UpdateLagCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateLag");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateLagCommand");
+var se_UpdateVirtualInterfaceAttributesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateVirtualInterfaceAttributes");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateVirtualInterfaceAttributesCommand");
+var de_AcceptDirectConnectGatewayAssociationProposalCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AcceptDirectConnectGatewayAssociationProposalCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AcceptDirectConnectGatewayAssociationProposalCommand");
+var de_AcceptDirectConnectGatewayAssociationProposalCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AcceptDirectConnectGatewayAssociationProposalCommandError");
+var de_AllocateConnectionOnInterconnectCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AllocateConnectionOnInterconnectCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Connection(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AllocateConnectionOnInterconnectCommand");
+var de_AllocateConnectionOnInterconnectCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AllocateConnectionOnInterconnectCommandError");
+var de_AllocateHostedConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AllocateHostedConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Connection(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AllocateHostedConnectionCommand");
+var de_AllocateHostedConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeysException":
+    case "com.amazonaws.directconnect#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.directconnect#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AllocateHostedConnectionCommandError");
+var de_AllocatePrivateVirtualInterfaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AllocatePrivateVirtualInterfaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AllocatePrivateVirtualInterfaceCommand");
+var de_AllocatePrivateVirtualInterfaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeysException":
+    case "com.amazonaws.directconnect#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.directconnect#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AllocatePrivateVirtualInterfaceCommandError");
+var de_AllocatePublicVirtualInterfaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AllocatePublicVirtualInterfaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AllocatePublicVirtualInterfaceCommand");
+var de_AllocatePublicVirtualInterfaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeysException":
+    case "com.amazonaws.directconnect#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.directconnect#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AllocatePublicVirtualInterfaceCommandError");
+var de_AllocateTransitVirtualInterfaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AllocateTransitVirtualInterfaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AllocateTransitVirtualInterfaceCommand");
+var de_AllocateTransitVirtualInterfaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeysException":
+    case "com.amazonaws.directconnect#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.directconnect#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AllocateTransitVirtualInterfaceCommandError");
+var de_AssociateConnectionWithLagCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateConnectionWithLagCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Connection(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AssociateConnectionWithLagCommand");
+var de_AssociateConnectionWithLagCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateConnectionWithLagCommandError");
+var de_AssociateHostedConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateHostedConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Connection(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AssociateHostedConnectionCommand");
+var de_AssociateHostedConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateHostedConnectionCommandError");
+var de_AssociateMacSecKeyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateMacSecKeyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AssociateMacSecKeyCommand");
+var de_AssociateMacSecKeyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateMacSecKeyCommandError");
+var de_AssociateVirtualInterfaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateVirtualInterfaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AssociateVirtualInterfaceCommand");
+var de_AssociateVirtualInterfaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateVirtualInterfaceCommandError");
+var de_ConfirmConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ConfirmConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ConfirmConnectionCommand");
+var de_ConfirmConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ConfirmConnectionCommandError");
+var de_ConfirmCustomerAgreementCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ConfirmCustomerAgreementCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ConfirmCustomerAgreementCommand");
+var de_ConfirmCustomerAgreementCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ConfirmCustomerAgreementCommandError");
+var de_ConfirmPrivateVirtualInterfaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ConfirmPrivateVirtualInterfaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ConfirmPrivateVirtualInterfaceCommand");
+var de_ConfirmPrivateVirtualInterfaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ConfirmPrivateVirtualInterfaceCommandError");
+var de_ConfirmPublicVirtualInterfaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ConfirmPublicVirtualInterfaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ConfirmPublicVirtualInterfaceCommand");
+var de_ConfirmPublicVirtualInterfaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ConfirmPublicVirtualInterfaceCommandError");
+var de_ConfirmTransitVirtualInterfaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ConfirmTransitVirtualInterfaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ConfirmTransitVirtualInterfaceCommand");
+var de_ConfirmTransitVirtualInterfaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ConfirmTransitVirtualInterfaceCommandError");
+var de_CreateBGPPeerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateBGPPeerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateBGPPeerCommand");
+var de_CreateBGPPeerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateBGPPeerCommandError");
+var de_CreateConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Connection(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateConnectionCommand");
+var de_CreateConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeysException":
+    case "com.amazonaws.directconnect#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.directconnect#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateConnectionCommandError");
+var de_CreateDirectConnectGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateDirectConnectGatewayCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateDirectConnectGatewayCommand");
+var de_CreateDirectConnectGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateDirectConnectGatewayCommandError");
+var de_CreateDirectConnectGatewayAssociationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateDirectConnectGatewayAssociationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateDirectConnectGatewayAssociationCommand");
+var de_CreateDirectConnectGatewayAssociationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateDirectConnectGatewayAssociationCommandError");
+var de_CreateDirectConnectGatewayAssociationProposalCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateDirectConnectGatewayAssociationProposalCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateDirectConnectGatewayAssociationProposalCommand");
+var de_CreateDirectConnectGatewayAssociationProposalCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateDirectConnectGatewayAssociationProposalCommandError");
+var de_CreateInterconnectCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateInterconnectCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Interconnect(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateInterconnectCommand");
+var de_CreateInterconnectCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeysException":
+    case "com.amazonaws.directconnect#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.directconnect#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateInterconnectCommandError");
+var de_CreateLagCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateLagCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Lag(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateLagCommand");
+var de_CreateLagCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeysException":
+    case "com.amazonaws.directconnect#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.directconnect#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateLagCommandError");
+var de_CreatePrivateVirtualInterfaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreatePrivateVirtualInterfaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreatePrivateVirtualInterfaceCommand");
+var de_CreatePrivateVirtualInterfaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeysException":
+    case "com.amazonaws.directconnect#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.directconnect#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreatePrivateVirtualInterfaceCommandError");
+var de_CreatePublicVirtualInterfaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreatePublicVirtualInterfaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreatePublicVirtualInterfaceCommand");
+var de_CreatePublicVirtualInterfaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeysException":
+    case "com.amazonaws.directconnect#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.directconnect#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreatePublicVirtualInterfaceCommandError");
+var de_CreateTransitVirtualInterfaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateTransitVirtualInterfaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateTransitVirtualInterfaceCommand");
+var de_CreateTransitVirtualInterfaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeysException":
+    case "com.amazonaws.directconnect#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.directconnect#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateTransitVirtualInterfaceCommandError");
+var de_DeleteBGPPeerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteBGPPeerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteBGPPeerCommand");
+var de_DeleteBGPPeerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteBGPPeerCommandError");
+var de_DeleteConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Connection(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteConnectionCommand");
+var de_DeleteConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteConnectionCommandError");
+var de_DeleteDirectConnectGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteDirectConnectGatewayCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteDirectConnectGatewayCommand");
+var de_DeleteDirectConnectGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteDirectConnectGatewayCommandError");
+var de_DeleteDirectConnectGatewayAssociationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteDirectConnectGatewayAssociationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteDirectConnectGatewayAssociationCommand");
+var de_DeleteDirectConnectGatewayAssociationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteDirectConnectGatewayAssociationCommandError");
+var de_DeleteDirectConnectGatewayAssociationProposalCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteDirectConnectGatewayAssociationProposalCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteDirectConnectGatewayAssociationProposalCommand");
+var de_DeleteDirectConnectGatewayAssociationProposalCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteDirectConnectGatewayAssociationProposalCommandError");
+var de_DeleteInterconnectCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteInterconnectCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteInterconnectCommand");
+var de_DeleteInterconnectCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteInterconnectCommandError");
+var de_DeleteLagCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteLagCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Lag(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteLagCommand");
+var de_DeleteLagCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteLagCommandError");
+var de_DeleteVirtualInterfaceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteVirtualInterfaceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteVirtualInterfaceCommand");
+var de_DeleteVirtualInterfaceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteVirtualInterfaceCommandError");
+var de_DescribeConnectionLoaCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeConnectionLoaCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeConnectionLoaResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeConnectionLoaCommand");
+var de_DescribeConnectionLoaCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeConnectionLoaCommandError");
+var de_DescribeConnectionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeConnectionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Connections(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeConnectionsCommand");
+var de_DescribeConnectionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeConnectionsCommandError");
+var de_DescribeConnectionsOnInterconnectCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeConnectionsOnInterconnectCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Connections(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeConnectionsOnInterconnectCommand");
+var de_DescribeConnectionsOnInterconnectCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeConnectionsOnInterconnectCommandError");
+var de_DescribeCustomerMetadataCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeCustomerMetadataCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeCustomerMetadataCommand");
+var de_DescribeCustomerMetadataCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCustomerMetadataCommandError");
+var de_DescribeDirectConnectGatewayAssociationProposalsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeDirectConnectGatewayAssociationProposalsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeDirectConnectGatewayAssociationProposalsCommand");
+var de_DescribeDirectConnectGatewayAssociationProposalsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeDirectConnectGatewayAssociationProposalsCommandError");
+var de_DescribeDirectConnectGatewayAssociationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeDirectConnectGatewayAssociationsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeDirectConnectGatewayAssociationsCommand");
+var de_DescribeDirectConnectGatewayAssociationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeDirectConnectGatewayAssociationsCommandError");
+var de_DescribeDirectConnectGatewayAttachmentsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeDirectConnectGatewayAttachmentsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeDirectConnectGatewayAttachmentsCommand");
+var de_DescribeDirectConnectGatewayAttachmentsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeDirectConnectGatewayAttachmentsCommandError");
+var de_DescribeDirectConnectGatewaysCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeDirectConnectGatewaysCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeDirectConnectGatewaysCommand");
+var de_DescribeDirectConnectGatewaysCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeDirectConnectGatewaysCommandError");
+var de_DescribeHostedConnectionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeHostedConnectionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Connections(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeHostedConnectionsCommand");
+var de_DescribeHostedConnectionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeHostedConnectionsCommandError");
+var de_DescribeInterconnectLoaCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeInterconnectLoaCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeInterconnectLoaResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeInterconnectLoaCommand");
+var de_DescribeInterconnectLoaCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeInterconnectLoaCommandError");
+var de_DescribeInterconnectsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeInterconnectsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Interconnects(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeInterconnectsCommand");
+var de_DescribeInterconnectsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeInterconnectsCommandError");
+var de_DescribeLagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeLagsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Lags(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeLagsCommand");
+var de_DescribeLagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeLagsCommandError");
+var de_DescribeLoaCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeLoaCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Loa(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeLoaCommand");
+var de_DescribeLoaCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeLoaCommandError");
+var de_DescribeLocationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeLocationsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeLocationsCommand");
+var de_DescribeLocationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeLocationsCommandError");
+var de_DescribeRouterConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeRouterConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeRouterConfigurationCommand");
+var de_DescribeRouterConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeRouterConfigurationCommandError");
+var de_DescribeTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeTagsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeTagsCommand");
+var de_DescribeTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeTagsCommandError");
+var de_DescribeVirtualGatewaysCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeVirtualGatewaysCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeVirtualGatewaysCommand");
+var de_DescribeVirtualGatewaysCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeVirtualGatewaysCommandError");
+var de_DescribeVirtualInterfacesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeVirtualInterfacesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeVirtualInterfacesCommand");
+var de_DescribeVirtualInterfacesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeVirtualInterfacesCommandError");
+var de_DisassociateConnectionFromLagCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisassociateConnectionFromLagCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Connection(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DisassociateConnectionFromLagCommand");
+var de_DisassociateConnectionFromLagCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisassociateConnectionFromLagCommandError");
+var de_DisassociateMacSecKeyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisassociateMacSecKeyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DisassociateMacSecKeyCommand");
+var de_DisassociateMacSecKeyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisassociateMacSecKeyCommandError");
+var de_ListVirtualInterfaceTestHistoryCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListVirtualInterfaceTestHistoryCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ListVirtualInterfaceTestHistoryResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListVirtualInterfaceTestHistoryCommand");
+var de_ListVirtualInterfaceTestHistoryCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListVirtualInterfaceTestHistoryCommandError");
+var de_StartBgpFailoverTestCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StartBgpFailoverTestCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_StartBgpFailoverTestResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StartBgpFailoverTestCommand");
+var de_StartBgpFailoverTestCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartBgpFailoverTestCommandError");
+var de_StopBgpFailoverTestCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_StopBgpFailoverTestCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_StopBgpFailoverTestResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_StopBgpFailoverTestCommand");
+var de_StopBgpFailoverTestCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StopBgpFailoverTestCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "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 "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeysException":
+    case "com.amazonaws.directconnect#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "TooManyTagsException":
+    case "com.amazonaws.directconnect#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 >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "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 "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateConnectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateConnectionCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Connection(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateConnectionCommand");
+var de_UpdateConnectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateConnectionCommandError");
+var de_UpdateDirectConnectGatewayCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateDirectConnectGatewayCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateDirectConnectGatewayCommand");
+var de_UpdateDirectConnectGatewayCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateDirectConnectGatewayCommandError");
+var de_UpdateDirectConnectGatewayAssociationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateDirectConnectGatewayAssociationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateDirectConnectGatewayAssociationCommand");
+var de_UpdateDirectConnectGatewayAssociationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateDirectConnectGatewayAssociationCommandError");
+var de_UpdateLagCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateLagCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_Lag(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateLagCommand");
+var de_UpdateLagCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateLagCommandError");
+var de_UpdateVirtualInterfaceAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateVirtualInterfaceAttributesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateVirtualInterfaceAttributesCommand");
+var de_UpdateVirtualInterfaceAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DirectConnectClientException":
+    case "com.amazonaws.directconnect#DirectConnectClientException":
+      throw await de_DirectConnectClientExceptionRes(parsedOutput, context);
+    case "DirectConnectServerException":
+    case "com.amazonaws.directconnect#DirectConnectServerException":
+      throw await de_DirectConnectServerExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateVirtualInterfaceAttributesCommandError");
+var de_DirectConnectClientExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new DirectConnectClientException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DirectConnectClientExceptionRes");
+var de_DirectConnectServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new DirectConnectServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DirectConnectServerExceptionRes");
+var de_DuplicateTagKeysExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new DuplicateTagKeysException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DuplicateTagKeysExceptionRes");
+var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TooManyTagsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TooManyTagsExceptionRes");
+var de_Connection = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    awsDevice: import_smithy_client.expectString,
+    awsDeviceV2: import_smithy_client.expectString,
+    awsLogicalDeviceId: import_smithy_client.expectString,
+    bandwidth: import_smithy_client.expectString,
+    connectionId: import_smithy_client.expectString,
+    connectionName: import_smithy_client.expectString,
+    connectionState: import_smithy_client.expectString,
+    encryptionMode: import_smithy_client.expectString,
+    hasLogicalRedundancy: import_smithy_client.expectString,
+    jumboFrameCapable: import_smithy_client.expectBoolean,
+    lagId: import_smithy_client.expectString,
+    loaIssueTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    location: import_smithy_client.expectString,
+    macSecCapable: import_smithy_client.expectBoolean,
+    macSecKeys: import_smithy_client._json,
+    ownerAccount: import_smithy_client.expectString,
+    partnerName: import_smithy_client.expectString,
+    portEncryptionStatus: import_smithy_client.expectString,
+    providerName: import_smithy_client.expectString,
+    region: import_smithy_client.expectString,
+    tags: import_smithy_client._json,
+    vlan: import_smithy_client.expectInt32
+  });
+}, "de_Connection");
+var de_ConnectionList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Connection(entry, context);
+  });
+  return retVal;
+}, "de_ConnectionList");
+var de_Connections = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    connections: (_) => de_ConnectionList(_, context)
+  });
+}, "de_Connections");
+var de_DescribeConnectionLoaResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    loa: (_) => de_Loa(_, context)
+  });
+}, "de_DescribeConnectionLoaResponse");
+var de_DescribeInterconnectLoaResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    loa: (_) => de_Loa(_, context)
+  });
+}, "de_DescribeInterconnectLoaResponse");
+var de_Interconnect = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    awsDevice: import_smithy_client.expectString,
+    awsDeviceV2: import_smithy_client.expectString,
+    awsLogicalDeviceId: import_smithy_client.expectString,
+    bandwidth: import_smithy_client.expectString,
+    hasLogicalRedundancy: import_smithy_client.expectString,
+    interconnectId: import_smithy_client.expectString,
+    interconnectName: import_smithy_client.expectString,
+    interconnectState: import_smithy_client.expectString,
+    jumboFrameCapable: import_smithy_client.expectBoolean,
+    lagId: import_smithy_client.expectString,
+    loaIssueTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    location: import_smithy_client.expectString,
+    providerName: import_smithy_client.expectString,
+    region: import_smithy_client.expectString,
+    tags: import_smithy_client._json
+  });
+}, "de_Interconnect");
+var de_InterconnectList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Interconnect(entry, context);
+  });
+  return retVal;
+}, "de_InterconnectList");
+var de_Interconnects = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    interconnects: (_) => de_InterconnectList(_, context)
+  });
+}, "de_Interconnects");
+var de_Lag = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    allowsHostedConnections: import_smithy_client.expectBoolean,
+    awsDevice: import_smithy_client.expectString,
+    awsDeviceV2: import_smithy_client.expectString,
+    awsLogicalDeviceId: import_smithy_client.expectString,
+    connections: (_) => de_ConnectionList(_, context),
+    connectionsBandwidth: import_smithy_client.expectString,
+    encryptionMode: import_smithy_client.expectString,
+    hasLogicalRedundancy: import_smithy_client.expectString,
+    jumboFrameCapable: import_smithy_client.expectBoolean,
+    lagId: import_smithy_client.expectString,
+    lagName: import_smithy_client.expectString,
+    lagState: import_smithy_client.expectString,
+    location: import_smithy_client.expectString,
+    macSecCapable: import_smithy_client.expectBoolean,
+    macSecKeys: import_smithy_client._json,
+    minimumLinks: import_smithy_client.expectInt32,
+    numberOfConnections: import_smithy_client.expectInt32,
+    ownerAccount: import_smithy_client.expectString,
+    providerName: import_smithy_client.expectString,
+    region: import_smithy_client.expectString,
+    tags: import_smithy_client._json
+  });
+}, "de_Lag");
+var de_LagList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Lag(entry, context);
+  });
+  return retVal;
+}, "de_LagList");
+var de_Lags = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    lags: (_) => de_LagList(_, context)
+  });
+}, "de_Lags");
+var de_ListVirtualInterfaceTestHistoryResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    nextToken: import_smithy_client.expectString,
+    virtualInterfaceTestHistory: (_) => de_VirtualInterfaceTestHistoryList(_, context)
+  });
+}, "de_ListVirtualInterfaceTestHistoryResponse");
+var de_Loa = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    loaContent: context.base64Decoder,
+    loaContentType: import_smithy_client.expectString
+  });
+}, "de_Loa");
+var de_StartBgpFailoverTestResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    virtualInterfaceTest: (_) => de_VirtualInterfaceTestHistory(_, context)
+  });
+}, "de_StartBgpFailoverTestResponse");
+var de_StopBgpFailoverTestResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    virtualInterfaceTest: (_) => de_VirtualInterfaceTestHistory(_, context)
+  });
+}, "de_StopBgpFailoverTestResponse");
+var de_VirtualInterfaceTestHistory = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    bgpPeers: import_smithy_client._json,
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    ownerAccount: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    status: import_smithy_client.expectString,
+    testDurationInMinutes: import_smithy_client.expectInt32,
+    testId: import_smithy_client.expectString,
+    virtualInterfaceId: import_smithy_client.expectString
+  });
+}, "de_VirtualInterfaceTestHistory");
+var de_VirtualInterfaceTestHistoryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_VirtualInterfaceTestHistory(entry, context);
+  });
+  return retVal;
+}, "de_VirtualInterfaceTestHistoryList");
+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 throwDefaultError = (0, import_smithy_client.withBaseException)(DirectConnectServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `OvertureService.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+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/AcceptDirectConnectGatewayAssociationProposalCommand.ts
+var _AcceptDirectConnectGatewayAssociationProposalCommand = class _AcceptDirectConnectGatewayAssociationProposalCommand 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("OvertureService", "AcceptDirectConnectGatewayAssociationProposal", {}).n("DirectConnectClient", "AcceptDirectConnectGatewayAssociationProposalCommand").f(void 0, void 0).ser(se_AcceptDirectConnectGatewayAssociationProposalCommand).de(de_AcceptDirectConnectGatewayAssociationProposalCommand).build() {
+};
+__name(_AcceptDirectConnectGatewayAssociationProposalCommand, "AcceptDirectConnectGatewayAssociationProposalCommand");
+var AcceptDirectConnectGatewayAssociationProposalCommand = _AcceptDirectConnectGatewayAssociationProposalCommand;
+
+// src/commands/AllocateConnectionOnInterconnectCommand.ts
+
+
+
+
+var _AllocateConnectionOnInterconnectCommand = class _AllocateConnectionOnInterconnectCommand 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("OvertureService", "AllocateConnectionOnInterconnect", {}).n("DirectConnectClient", "AllocateConnectionOnInterconnectCommand").f(void 0, void 0).ser(se_AllocateConnectionOnInterconnectCommand).de(de_AllocateConnectionOnInterconnectCommand).build() {
+};
+__name(_AllocateConnectionOnInterconnectCommand, "AllocateConnectionOnInterconnectCommand");
+var AllocateConnectionOnInterconnectCommand = _AllocateConnectionOnInterconnectCommand;
+
+// src/commands/AllocateHostedConnectionCommand.ts
+
+
+
+
+var _AllocateHostedConnectionCommand = class _AllocateHostedConnectionCommand 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("OvertureService", "AllocateHostedConnection", {}).n("DirectConnectClient", "AllocateHostedConnectionCommand").f(void 0, void 0).ser(se_AllocateHostedConnectionCommand).de(de_AllocateHostedConnectionCommand).build() {
+};
+__name(_AllocateHostedConnectionCommand, "AllocateHostedConnectionCommand");
+var AllocateHostedConnectionCommand = _AllocateHostedConnectionCommand;
+
+// src/commands/AllocatePrivateVirtualInterfaceCommand.ts
+
+
+
+
+var _AllocatePrivateVirtualInterfaceCommand = class _AllocatePrivateVirtualInterfaceCommand 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("OvertureService", "AllocatePrivateVirtualInterface", {}).n("DirectConnectClient", "AllocatePrivateVirtualInterfaceCommand").f(void 0, void 0).ser(se_AllocatePrivateVirtualInterfaceCommand).de(de_AllocatePrivateVirtualInterfaceCommand).build() {
+};
+__name(_AllocatePrivateVirtualInterfaceCommand, "AllocatePrivateVirtualInterfaceCommand");
+var AllocatePrivateVirtualInterfaceCommand = _AllocatePrivateVirtualInterfaceCommand;
+
+// src/commands/AllocatePublicVirtualInterfaceCommand.ts
+
+
+
+
+var _AllocatePublicVirtualInterfaceCommand = class _AllocatePublicVirtualInterfaceCommand 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("OvertureService", "AllocatePublicVirtualInterface", {}).n("DirectConnectClient", "AllocatePublicVirtualInterfaceCommand").f(void 0, void 0).ser(se_AllocatePublicVirtualInterfaceCommand).de(de_AllocatePublicVirtualInterfaceCommand).build() {
+};
+__name(_AllocatePublicVirtualInterfaceCommand, "AllocatePublicVirtualInterfaceCommand");
+var AllocatePublicVirtualInterfaceCommand = _AllocatePublicVirtualInterfaceCommand;
+
+// src/commands/AllocateTransitVirtualInterfaceCommand.ts
+
+
+
+
+var _AllocateTransitVirtualInterfaceCommand = class _AllocateTransitVirtualInterfaceCommand 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("OvertureService", "AllocateTransitVirtualInterface", {}).n("DirectConnectClient", "AllocateTransitVirtualInterfaceCommand").f(void 0, void 0).ser(se_AllocateTransitVirtualInterfaceCommand).de(de_AllocateTransitVirtualInterfaceCommand).build() {
+};
+__name(_AllocateTransitVirtualInterfaceCommand, "AllocateTransitVirtualInterfaceCommand");
+var AllocateTransitVirtualInterfaceCommand = _AllocateTransitVirtualInterfaceCommand;
+
+// src/commands/AssociateConnectionWithLagCommand.ts
+
+
+
+
+var _AssociateConnectionWithLagCommand = class _AssociateConnectionWithLagCommand 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("OvertureService", "AssociateConnectionWithLag", {}).n("DirectConnectClient", "AssociateConnectionWithLagCommand").f(void 0, void 0).ser(se_AssociateConnectionWithLagCommand).de(de_AssociateConnectionWithLagCommand).build() {
+};
+__name(_AssociateConnectionWithLagCommand, "AssociateConnectionWithLagCommand");
+var AssociateConnectionWithLagCommand = _AssociateConnectionWithLagCommand;
+
+// src/commands/AssociateHostedConnectionCommand.ts
+
+
+
+
+var _AssociateHostedConnectionCommand = class _AssociateHostedConnectionCommand 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("OvertureService", "AssociateHostedConnection", {}).n("DirectConnectClient", "AssociateHostedConnectionCommand").f(void 0, void 0).ser(se_AssociateHostedConnectionCommand).de(de_AssociateHostedConnectionCommand).build() {
+};
+__name(_AssociateHostedConnectionCommand, "AssociateHostedConnectionCommand");
+var AssociateHostedConnectionCommand = _AssociateHostedConnectionCommand;
+
+// src/commands/AssociateMacSecKeyCommand.ts
+
+
+
+
+var _AssociateMacSecKeyCommand = class _AssociateMacSecKeyCommand 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("OvertureService", "AssociateMacSecKey", {}).n("DirectConnectClient", "AssociateMacSecKeyCommand").f(void 0, void 0).ser(se_AssociateMacSecKeyCommand).de(de_AssociateMacSecKeyCommand).build() {
+};
+__name(_AssociateMacSecKeyCommand, "AssociateMacSecKeyCommand");
+var AssociateMacSecKeyCommand = _AssociateMacSecKeyCommand;
+
+// src/commands/AssociateVirtualInterfaceCommand.ts
+
+
+
+
+var _AssociateVirtualInterfaceCommand = class _AssociateVirtualInterfaceCommand 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("OvertureService", "AssociateVirtualInterface", {}).n("DirectConnectClient", "AssociateVirtualInterfaceCommand").f(void 0, void 0).ser(se_AssociateVirtualInterfaceCommand).de(de_AssociateVirtualInterfaceCommand).build() {
+};
+__name(_AssociateVirtualInterfaceCommand, "AssociateVirtualInterfaceCommand");
+var AssociateVirtualInterfaceCommand = _AssociateVirtualInterfaceCommand;
+
+// src/commands/ConfirmConnectionCommand.ts
+
+
+
+
+var _ConfirmConnectionCommand = class _ConfirmConnectionCommand 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("OvertureService", "ConfirmConnection", {}).n("DirectConnectClient", "ConfirmConnectionCommand").f(void 0, void 0).ser(se_ConfirmConnectionCommand).de(de_ConfirmConnectionCommand).build() {
+};
+__name(_ConfirmConnectionCommand, "ConfirmConnectionCommand");
+var ConfirmConnectionCommand = _ConfirmConnectionCommand;
+
+// src/commands/ConfirmCustomerAgreementCommand.ts
+
+
+
+
+var _ConfirmCustomerAgreementCommand = class _ConfirmCustomerAgreementCommand 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("OvertureService", "ConfirmCustomerAgreement", {}).n("DirectConnectClient", "ConfirmCustomerAgreementCommand").f(void 0, void 0).ser(se_ConfirmCustomerAgreementCommand).de(de_ConfirmCustomerAgreementCommand).build() {
+};
+__name(_ConfirmCustomerAgreementCommand, "ConfirmCustomerAgreementCommand");
+var ConfirmCustomerAgreementCommand = _ConfirmCustomerAgreementCommand;
+
+// src/commands/ConfirmPrivateVirtualInterfaceCommand.ts
+
+
+
+
+var _ConfirmPrivateVirtualInterfaceCommand = class _ConfirmPrivateVirtualInterfaceCommand 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("OvertureService", "ConfirmPrivateVirtualInterface", {}).n("DirectConnectClient", "ConfirmPrivateVirtualInterfaceCommand").f(void 0, void 0).ser(se_ConfirmPrivateVirtualInterfaceCommand).de(de_ConfirmPrivateVirtualInterfaceCommand).build() {
+};
+__name(_ConfirmPrivateVirtualInterfaceCommand, "ConfirmPrivateVirtualInterfaceCommand");
+var ConfirmPrivateVirtualInterfaceCommand = _ConfirmPrivateVirtualInterfaceCommand;
+
+// src/commands/ConfirmPublicVirtualInterfaceCommand.ts
+
+
+
+
+var _ConfirmPublicVirtualInterfaceCommand = class _ConfirmPublicVirtualInterfaceCommand 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("OvertureService", "ConfirmPublicVirtualInterface", {}).n("DirectConnectClient", "ConfirmPublicVirtualInterfaceCommand").f(void 0, void 0).ser(se_ConfirmPublicVirtualInterfaceCommand).de(de_ConfirmPublicVirtualInterfaceCommand).build() {
+};
+__name(_ConfirmPublicVirtualInterfaceCommand, "ConfirmPublicVirtualInterfaceCommand");
+var ConfirmPublicVirtualInterfaceCommand = _ConfirmPublicVirtualInterfaceCommand;
+
+// src/commands/ConfirmTransitVirtualInterfaceCommand.ts
+
+
+
+
+var _ConfirmTransitVirtualInterfaceCommand = class _ConfirmTransitVirtualInterfaceCommand 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("OvertureService", "ConfirmTransitVirtualInterface", {}).n("DirectConnectClient", "ConfirmTransitVirtualInterfaceCommand").f(void 0, void 0).ser(se_ConfirmTransitVirtualInterfaceCommand).de(de_ConfirmTransitVirtualInterfaceCommand).build() {
+};
+__name(_ConfirmTransitVirtualInterfaceCommand, "ConfirmTransitVirtualInterfaceCommand");
+var ConfirmTransitVirtualInterfaceCommand = _ConfirmTransitVirtualInterfaceCommand;
+
+// src/commands/CreateBGPPeerCommand.ts
+
+
+
+
+var _CreateBGPPeerCommand = class _CreateBGPPeerCommand 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("OvertureService", "CreateBGPPeer", {}).n("DirectConnectClient", "CreateBGPPeerCommand").f(void 0, void 0).ser(se_CreateBGPPeerCommand).de(de_CreateBGPPeerCommand).build() {
+};
+__name(_CreateBGPPeerCommand, "CreateBGPPeerCommand");
+var CreateBGPPeerCommand = _CreateBGPPeerCommand;
+
+// src/commands/CreateConnectionCommand.ts
+
+
+
+
+var _CreateConnectionCommand = class _CreateConnectionCommand 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("OvertureService", "CreateConnection", {}).n("DirectConnectClient", "CreateConnectionCommand").f(void 0, void 0).ser(se_CreateConnectionCommand).de(de_CreateConnectionCommand).build() {
+};
+__name(_CreateConnectionCommand, "CreateConnectionCommand");
+var CreateConnectionCommand = _CreateConnectionCommand;
+
+// src/commands/CreateDirectConnectGatewayAssociationCommand.ts
+
+
+
+
+var _CreateDirectConnectGatewayAssociationCommand = class _CreateDirectConnectGatewayAssociationCommand 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("OvertureService", "CreateDirectConnectGatewayAssociation", {}).n("DirectConnectClient", "CreateDirectConnectGatewayAssociationCommand").f(void 0, void 0).ser(se_CreateDirectConnectGatewayAssociationCommand).de(de_CreateDirectConnectGatewayAssociationCommand).build() {
+};
+__name(_CreateDirectConnectGatewayAssociationCommand, "CreateDirectConnectGatewayAssociationCommand");
+var CreateDirectConnectGatewayAssociationCommand = _CreateDirectConnectGatewayAssociationCommand;
+
+// src/commands/CreateDirectConnectGatewayAssociationProposalCommand.ts
+
+
+
+
+var _CreateDirectConnectGatewayAssociationProposalCommand = class _CreateDirectConnectGatewayAssociationProposalCommand 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("OvertureService", "CreateDirectConnectGatewayAssociationProposal", {}).n("DirectConnectClient", "CreateDirectConnectGatewayAssociationProposalCommand").f(void 0, void 0).ser(se_CreateDirectConnectGatewayAssociationProposalCommand).de(de_CreateDirectConnectGatewayAssociationProposalCommand).build() {
+};
+__name(_CreateDirectConnectGatewayAssociationProposalCommand, "CreateDirectConnectGatewayAssociationProposalCommand");
+var CreateDirectConnectGatewayAssociationProposalCommand = _CreateDirectConnectGatewayAssociationProposalCommand;
+
+// src/commands/CreateDirectConnectGatewayCommand.ts
+
+
+
+
+var _CreateDirectConnectGatewayCommand = class _CreateDirectConnectGatewayCommand 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("OvertureService", "CreateDirectConnectGateway", {}).n("DirectConnectClient", "CreateDirectConnectGatewayCommand").f(void 0, void 0).ser(se_CreateDirectConnectGatewayCommand).de(de_CreateDirectConnectGatewayCommand).build() {
+};
+__name(_CreateDirectConnectGatewayCommand, "CreateDirectConnectGatewayCommand");
+var CreateDirectConnectGatewayCommand = _CreateDirectConnectGatewayCommand;
+
+// src/commands/CreateInterconnectCommand.ts
+
+
+
+
+var _CreateInterconnectCommand = class _CreateInterconnectCommand 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("OvertureService", "CreateInterconnect", {}).n("DirectConnectClient", "CreateInterconnectCommand").f(void 0, void 0).ser(se_CreateInterconnectCommand).de(de_CreateInterconnectCommand).build() {
+};
+__name(_CreateInterconnectCommand, "CreateInterconnectCommand");
+var CreateInterconnectCommand = _CreateInterconnectCommand;
+
+// src/commands/CreateLagCommand.ts
+
+
+
+
+var _CreateLagCommand = class _CreateLagCommand 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("OvertureService", "CreateLag", {}).n("DirectConnectClient", "CreateLagCommand").f(void 0, void 0).ser(se_CreateLagCommand).de(de_CreateLagCommand).build() {
+};
+__name(_CreateLagCommand, "CreateLagCommand");
+var CreateLagCommand = _CreateLagCommand;
+
+// src/commands/CreatePrivateVirtualInterfaceCommand.ts
+
+
+
+
+var _CreatePrivateVirtualInterfaceCommand = class _CreatePrivateVirtualInterfaceCommand 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("OvertureService", "CreatePrivateVirtualInterface", {}).n("DirectConnectClient", "CreatePrivateVirtualInterfaceCommand").f(void 0, void 0).ser(se_CreatePrivateVirtualInterfaceCommand).de(de_CreatePrivateVirtualInterfaceCommand).build() {
+};
+__name(_CreatePrivateVirtualInterfaceCommand, "CreatePrivateVirtualInterfaceCommand");
+var CreatePrivateVirtualInterfaceCommand = _CreatePrivateVirtualInterfaceCommand;
+
+// src/commands/CreatePublicVirtualInterfaceCommand.ts
+
+
+
+
+var _CreatePublicVirtualInterfaceCommand = class _CreatePublicVirtualInterfaceCommand 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("OvertureService", "CreatePublicVirtualInterface", {}).n("DirectConnectClient", "CreatePublicVirtualInterfaceCommand").f(void 0, void 0).ser(se_CreatePublicVirtualInterfaceCommand).de(de_CreatePublicVirtualInterfaceCommand).build() {
+};
+__name(_CreatePublicVirtualInterfaceCommand, "CreatePublicVirtualInterfaceCommand");
+var CreatePublicVirtualInterfaceCommand = _CreatePublicVirtualInterfaceCommand;
+
+// src/commands/CreateTransitVirtualInterfaceCommand.ts
+
+
+
+
+var _CreateTransitVirtualInterfaceCommand = class _CreateTransitVirtualInterfaceCommand 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("OvertureService", "CreateTransitVirtualInterface", {}).n("DirectConnectClient", "CreateTransitVirtualInterfaceCommand").f(void 0, void 0).ser(se_CreateTransitVirtualInterfaceCommand).de(de_CreateTransitVirtualInterfaceCommand).build() {
+};
+__name(_CreateTransitVirtualInterfaceCommand, "CreateTransitVirtualInterfaceCommand");
+var CreateTransitVirtualInterfaceCommand = _CreateTransitVirtualInterfaceCommand;
+
+// src/commands/DeleteBGPPeerCommand.ts
+
+
+
+
+var _DeleteBGPPeerCommand = class _DeleteBGPPeerCommand 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("OvertureService", "DeleteBGPPeer", {}).n("DirectConnectClient", "DeleteBGPPeerCommand").f(void 0, void 0).ser(se_DeleteBGPPeerCommand).de(de_DeleteBGPPeerCommand).build() {
+};
+__name(_DeleteBGPPeerCommand, "DeleteBGPPeerCommand");
+var DeleteBGPPeerCommand = _DeleteBGPPeerCommand;
+
+// src/commands/DeleteConnectionCommand.ts
+
+
+
+
+var _DeleteConnectionCommand = class _DeleteConnectionCommand 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("OvertureService", "DeleteConnection", {}).n("DirectConnectClient", "DeleteConnectionCommand").f(void 0, void 0).ser(se_DeleteConnectionCommand).de(de_DeleteConnectionCommand).build() {
+};
+__name(_DeleteConnectionCommand, "DeleteConnectionCommand");
+var DeleteConnectionCommand = _DeleteConnectionCommand;
+
+// src/commands/DeleteDirectConnectGatewayAssociationCommand.ts
+
+
+
+
+var _DeleteDirectConnectGatewayAssociationCommand = class _DeleteDirectConnectGatewayAssociationCommand 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("OvertureService", "DeleteDirectConnectGatewayAssociation", {}).n("DirectConnectClient", "DeleteDirectConnectGatewayAssociationCommand").f(void 0, void 0).ser(se_DeleteDirectConnectGatewayAssociationCommand).de(de_DeleteDirectConnectGatewayAssociationCommand).build() {
+};
+__name(_DeleteDirectConnectGatewayAssociationCommand, "DeleteDirectConnectGatewayAssociationCommand");
+var DeleteDirectConnectGatewayAssociationCommand = _DeleteDirectConnectGatewayAssociationCommand;
+
+// src/commands/DeleteDirectConnectGatewayAssociationProposalCommand.ts
+
+
+
+
+var _DeleteDirectConnectGatewayAssociationProposalCommand = class _DeleteDirectConnectGatewayAssociationProposalCommand 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("OvertureService", "DeleteDirectConnectGatewayAssociationProposal", {}).n("DirectConnectClient", "DeleteDirectConnectGatewayAssociationProposalCommand").f(void 0, void 0).ser(se_DeleteDirectConnectGatewayAssociationProposalCommand).de(de_DeleteDirectConnectGatewayAssociationProposalCommand).build() {
+};
+__name(_DeleteDirectConnectGatewayAssociationProposalCommand, "DeleteDirectConnectGatewayAssociationProposalCommand");
+var DeleteDirectConnectGatewayAssociationProposalCommand = _DeleteDirectConnectGatewayAssociationProposalCommand;
+
+// src/commands/DeleteDirectConnectGatewayCommand.ts
+
+
+
+
+var _DeleteDirectConnectGatewayCommand = class _DeleteDirectConnectGatewayCommand 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("OvertureService", "DeleteDirectConnectGateway", {}).n("DirectConnectClient", "DeleteDirectConnectGatewayCommand").f(void 0, void 0).ser(se_DeleteDirectConnectGatewayCommand).de(de_DeleteDirectConnectGatewayCommand).build() {
+};
+__name(_DeleteDirectConnectGatewayCommand, "DeleteDirectConnectGatewayCommand");
+var DeleteDirectConnectGatewayCommand = _DeleteDirectConnectGatewayCommand;
+
+// src/commands/DeleteInterconnectCommand.ts
+
+
+
+
+var _DeleteInterconnectCommand = class _DeleteInterconnectCommand 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("OvertureService", "DeleteInterconnect", {}).n("DirectConnectClient", "DeleteInterconnectCommand").f(void 0, void 0).ser(se_DeleteInterconnectCommand).de(de_DeleteInterconnectCommand).build() {
+};
+__name(_DeleteInterconnectCommand, "DeleteInterconnectCommand");
+var DeleteInterconnectCommand = _DeleteInterconnectCommand;
+
+// src/commands/DeleteLagCommand.ts
+
+
+
+
+var _DeleteLagCommand = class _DeleteLagCommand 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("OvertureService", "DeleteLag", {}).n("DirectConnectClient", "DeleteLagCommand").f(void 0, void 0).ser(se_DeleteLagCommand).de(de_DeleteLagCommand).build() {
+};
+__name(_DeleteLagCommand, "DeleteLagCommand");
+var DeleteLagCommand = _DeleteLagCommand;
+
+// src/commands/DeleteVirtualInterfaceCommand.ts
+
+
+
+
+var _DeleteVirtualInterfaceCommand = class _DeleteVirtualInterfaceCommand 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("OvertureService", "DeleteVirtualInterface", {}).n("DirectConnectClient", "DeleteVirtualInterfaceCommand").f(void 0, void 0).ser(se_DeleteVirtualInterfaceCommand).de(de_DeleteVirtualInterfaceCommand).build() {
+};
+__name(_DeleteVirtualInterfaceCommand, "DeleteVirtualInterfaceCommand");
+var DeleteVirtualInterfaceCommand = _DeleteVirtualInterfaceCommand;
+
+// src/commands/DescribeConnectionLoaCommand.ts
+
+
+
+
+var _DescribeConnectionLoaCommand = class _DescribeConnectionLoaCommand 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("OvertureService", "DescribeConnectionLoa", {}).n("DirectConnectClient", "DescribeConnectionLoaCommand").f(void 0, void 0).ser(se_DescribeConnectionLoaCommand).de(de_DescribeConnectionLoaCommand).build() {
+};
+__name(_DescribeConnectionLoaCommand, "DescribeConnectionLoaCommand");
+var DescribeConnectionLoaCommand = _DescribeConnectionLoaCommand;
+
+// src/commands/DescribeConnectionsCommand.ts
+
+
+
+
+var _DescribeConnectionsCommand = class _DescribeConnectionsCommand 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("OvertureService", "DescribeConnections", {}).n("DirectConnectClient", "DescribeConnectionsCommand").f(void 0, void 0).ser(se_DescribeConnectionsCommand).de(de_DescribeConnectionsCommand).build() {
+};
+__name(_DescribeConnectionsCommand, "DescribeConnectionsCommand");
+var DescribeConnectionsCommand = _DescribeConnectionsCommand;
+
+// src/commands/DescribeConnectionsOnInterconnectCommand.ts
+
+
+
+
+var _DescribeConnectionsOnInterconnectCommand = class _DescribeConnectionsOnInterconnectCommand 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("OvertureService", "DescribeConnectionsOnInterconnect", {}).n("DirectConnectClient", "DescribeConnectionsOnInterconnectCommand").f(void 0, void 0).ser(se_DescribeConnectionsOnInterconnectCommand).de(de_DescribeConnectionsOnInterconnectCommand).build() {
+};
+__name(_DescribeConnectionsOnInterconnectCommand, "DescribeConnectionsOnInterconnectCommand");
+var DescribeConnectionsOnInterconnectCommand = _DescribeConnectionsOnInterconnectCommand;
+
+// src/commands/DescribeCustomerMetadataCommand.ts
+
+
+
+
+var _DescribeCustomerMetadataCommand = class _DescribeCustomerMetadataCommand 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("OvertureService", "DescribeCustomerMetadata", {}).n("DirectConnectClient", "DescribeCustomerMetadataCommand").f(void 0, void 0).ser(se_DescribeCustomerMetadataCommand).de(de_DescribeCustomerMetadataCommand).build() {
+};
+__name(_DescribeCustomerMetadataCommand, "DescribeCustomerMetadataCommand");
+var DescribeCustomerMetadataCommand = _DescribeCustomerMetadataCommand;
+
+// src/commands/DescribeDirectConnectGatewayAssociationProposalsCommand.ts
+
+
+
+
+var _DescribeDirectConnectGatewayAssociationProposalsCommand = class _DescribeDirectConnectGatewayAssociationProposalsCommand 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("OvertureService", "DescribeDirectConnectGatewayAssociationProposals", {}).n("DirectConnectClient", "DescribeDirectConnectGatewayAssociationProposalsCommand").f(void 0, void 0).ser(se_DescribeDirectConnectGatewayAssociationProposalsCommand).de(de_DescribeDirectConnectGatewayAssociationProposalsCommand).build() {
+};
+__name(_DescribeDirectConnectGatewayAssociationProposalsCommand, "DescribeDirectConnectGatewayAssociationProposalsCommand");
+var DescribeDirectConnectGatewayAssociationProposalsCommand = _DescribeDirectConnectGatewayAssociationProposalsCommand;
+
+// src/commands/DescribeDirectConnectGatewayAssociationsCommand.ts
+
+
+
+
+var _DescribeDirectConnectGatewayAssociationsCommand = class _DescribeDirectConnectGatewayAssociationsCommand 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("OvertureService", "DescribeDirectConnectGatewayAssociations", {}).n("DirectConnectClient", "DescribeDirectConnectGatewayAssociationsCommand").f(void 0, void 0).ser(se_DescribeDirectConnectGatewayAssociationsCommand).de(de_DescribeDirectConnectGatewayAssociationsCommand).build() {
+};
+__name(_DescribeDirectConnectGatewayAssociationsCommand, "DescribeDirectConnectGatewayAssociationsCommand");
+var DescribeDirectConnectGatewayAssociationsCommand = _DescribeDirectConnectGatewayAssociationsCommand;
+
+// src/commands/DescribeDirectConnectGatewayAttachmentsCommand.ts
+
+
+
+
+var _DescribeDirectConnectGatewayAttachmentsCommand = class _DescribeDirectConnectGatewayAttachmentsCommand 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("OvertureService", "DescribeDirectConnectGatewayAttachments", {}).n("DirectConnectClient", "DescribeDirectConnectGatewayAttachmentsCommand").f(void 0, void 0).ser(se_DescribeDirectConnectGatewayAttachmentsCommand).de(de_DescribeDirectConnectGatewayAttachmentsCommand).build() {
+};
+__name(_DescribeDirectConnectGatewayAttachmentsCommand, "DescribeDirectConnectGatewayAttachmentsCommand");
+var DescribeDirectConnectGatewayAttachmentsCommand = _DescribeDirectConnectGatewayAttachmentsCommand;
+
+// src/commands/DescribeDirectConnectGatewaysCommand.ts
+
+
+
+
+var _DescribeDirectConnectGatewaysCommand = class _DescribeDirectConnectGatewaysCommand 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("OvertureService", "DescribeDirectConnectGateways", {}).n("DirectConnectClient", "DescribeDirectConnectGatewaysCommand").f(void 0, void 0).ser(se_DescribeDirectConnectGatewaysCommand).de(de_DescribeDirectConnectGatewaysCommand).build() {
+};
+__name(_DescribeDirectConnectGatewaysCommand, "DescribeDirectConnectGatewaysCommand");
+var DescribeDirectConnectGatewaysCommand = _DescribeDirectConnectGatewaysCommand;
+
+// src/commands/DescribeHostedConnectionsCommand.ts
+
+
+
+
+var _DescribeHostedConnectionsCommand = class _DescribeHostedConnectionsCommand 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("OvertureService", "DescribeHostedConnections", {}).n("DirectConnectClient", "DescribeHostedConnectionsCommand").f(void 0, void 0).ser(se_DescribeHostedConnectionsCommand).de(de_DescribeHostedConnectionsCommand).build() {
+};
+__name(_DescribeHostedConnectionsCommand, "DescribeHostedConnectionsCommand");
+var DescribeHostedConnectionsCommand = _DescribeHostedConnectionsCommand;
+
+// src/commands/DescribeInterconnectLoaCommand.ts
+
+
+
+
+var _DescribeInterconnectLoaCommand = class _DescribeInterconnectLoaCommand 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("OvertureService", "DescribeInterconnectLoa", {}).n("DirectConnectClient", "DescribeInterconnectLoaCommand").f(void 0, void 0).ser(se_DescribeInterconnectLoaCommand).de(de_DescribeInterconnectLoaCommand).build() {
+};
+__name(_DescribeInterconnectLoaCommand, "DescribeInterconnectLoaCommand");
+var DescribeInterconnectLoaCommand = _DescribeInterconnectLoaCommand;
+
+// src/commands/DescribeInterconnectsCommand.ts
+
+
+
+
+var _DescribeInterconnectsCommand = class _DescribeInterconnectsCommand 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("OvertureService", "DescribeInterconnects", {}).n("DirectConnectClient", "DescribeInterconnectsCommand").f(void 0, void 0).ser(se_DescribeInterconnectsCommand).de(de_DescribeInterconnectsCommand).build() {
+};
+__name(_DescribeInterconnectsCommand, "DescribeInterconnectsCommand");
+var DescribeInterconnectsCommand = _DescribeInterconnectsCommand;
+
+// src/commands/DescribeLagsCommand.ts
+
+
+
+
+var _DescribeLagsCommand = class _DescribeLagsCommand 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("OvertureService", "DescribeLags", {}).n("DirectConnectClient", "DescribeLagsCommand").f(void 0, void 0).ser(se_DescribeLagsCommand).de(de_DescribeLagsCommand).build() {
+};
+__name(_DescribeLagsCommand, "DescribeLagsCommand");
+var DescribeLagsCommand = _DescribeLagsCommand;
+
+// src/commands/DescribeLoaCommand.ts
+
+
+
+
+var _DescribeLoaCommand = class _DescribeLoaCommand 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("OvertureService", "DescribeLoa", {}).n("DirectConnectClient", "DescribeLoaCommand").f(void 0, void 0).ser(se_DescribeLoaCommand).de(de_DescribeLoaCommand).build() {
+};
+__name(_DescribeLoaCommand, "DescribeLoaCommand");
+var DescribeLoaCommand = _DescribeLoaCommand;
+
+// src/commands/DescribeLocationsCommand.ts
+
+
+
+
+var _DescribeLocationsCommand = class _DescribeLocationsCommand 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("OvertureService", "DescribeLocations", {}).n("DirectConnectClient", "DescribeLocationsCommand").f(void 0, void 0).ser(se_DescribeLocationsCommand).de(de_DescribeLocationsCommand).build() {
+};
+__name(_DescribeLocationsCommand, "DescribeLocationsCommand");
+var DescribeLocationsCommand = _DescribeLocationsCommand;
+
+// src/commands/DescribeRouterConfigurationCommand.ts
+
+
+
+
+var _DescribeRouterConfigurationCommand = class _DescribeRouterConfigurationCommand 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("OvertureService", "DescribeRouterConfiguration", {}).n("DirectConnectClient", "DescribeRouterConfigurationCommand").f(void 0, void 0).ser(se_DescribeRouterConfigurationCommand).de(de_DescribeRouterConfigurationCommand).build() {
+};
+__name(_DescribeRouterConfigurationCommand, "DescribeRouterConfigurationCommand");
+var DescribeRouterConfigurationCommand = _DescribeRouterConfigurationCommand;
+
+// src/commands/DescribeTagsCommand.ts
+
+
+
+
+var _DescribeTagsCommand = class _DescribeTagsCommand 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("OvertureService", "DescribeTags", {}).n("DirectConnectClient", "DescribeTagsCommand").f(void 0, void 0).ser(se_DescribeTagsCommand).de(de_DescribeTagsCommand).build() {
+};
+__name(_DescribeTagsCommand, "DescribeTagsCommand");
+var DescribeTagsCommand = _DescribeTagsCommand;
+
+// src/commands/DescribeVirtualGatewaysCommand.ts
+
+
+
+
+var _DescribeVirtualGatewaysCommand = class _DescribeVirtualGatewaysCommand 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("OvertureService", "DescribeVirtualGateways", {}).n("DirectConnectClient", "DescribeVirtualGatewaysCommand").f(void 0, void 0).ser(se_DescribeVirtualGatewaysCommand).de(de_DescribeVirtualGatewaysCommand).build() {
+};
+__name(_DescribeVirtualGatewaysCommand, "DescribeVirtualGatewaysCommand");
+var DescribeVirtualGatewaysCommand = _DescribeVirtualGatewaysCommand;
+
+// src/commands/DescribeVirtualInterfacesCommand.ts
+
+
+
+
+var _DescribeVirtualInterfacesCommand = class _DescribeVirtualInterfacesCommand 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("OvertureService", "DescribeVirtualInterfaces", {}).n("DirectConnectClient", "DescribeVirtualInterfacesCommand").f(void 0, void 0).ser(se_DescribeVirtualInterfacesCommand).de(de_DescribeVirtualInterfacesCommand).build() {
+};
+__name(_DescribeVirtualInterfacesCommand, "DescribeVirtualInterfacesCommand");
+var DescribeVirtualInterfacesCommand = _DescribeVirtualInterfacesCommand;
+
+// src/commands/DisassociateConnectionFromLagCommand.ts
+
+
+
+
+var _DisassociateConnectionFromLagCommand = class _DisassociateConnectionFromLagCommand 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("OvertureService", "DisassociateConnectionFromLag", {}).n("DirectConnectClient", "DisassociateConnectionFromLagCommand").f(void 0, void 0).ser(se_DisassociateConnectionFromLagCommand).de(de_DisassociateConnectionFromLagCommand).build() {
+};
+__name(_DisassociateConnectionFromLagCommand, "DisassociateConnectionFromLagCommand");
+var DisassociateConnectionFromLagCommand = _DisassociateConnectionFromLagCommand;
+
+// src/commands/DisassociateMacSecKeyCommand.ts
+
+
+
+
+var _DisassociateMacSecKeyCommand = class _DisassociateMacSecKeyCommand 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("OvertureService", "DisassociateMacSecKey", {}).n("DirectConnectClient", "DisassociateMacSecKeyCommand").f(void 0, void 0).ser(se_DisassociateMacSecKeyCommand).de(de_DisassociateMacSecKeyCommand).build() {
+};
+__name(_DisassociateMacSecKeyCommand, "DisassociateMacSecKeyCommand");
+var DisassociateMacSecKeyCommand = _DisassociateMacSecKeyCommand;
+
+// src/commands/ListVirtualInterfaceTestHistoryCommand.ts
+
+
+
+
+var _ListVirtualInterfaceTestHistoryCommand = class _ListVirtualInterfaceTestHistoryCommand 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("OvertureService", "ListVirtualInterfaceTestHistory", {}).n("DirectConnectClient", "ListVirtualInterfaceTestHistoryCommand").f(void 0, void 0).ser(se_ListVirtualInterfaceTestHistoryCommand).de(de_ListVirtualInterfaceTestHistoryCommand).build() {
+};
+__name(_ListVirtualInterfaceTestHistoryCommand, "ListVirtualInterfaceTestHistoryCommand");
+var ListVirtualInterfaceTestHistoryCommand = _ListVirtualInterfaceTestHistoryCommand;
+
+// src/commands/StartBgpFailoverTestCommand.ts
+
+
+
+
+var _StartBgpFailoverTestCommand = class _StartBgpFailoverTestCommand 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("OvertureService", "StartBgpFailoverTest", {}).n("DirectConnectClient", "StartBgpFailoverTestCommand").f(void 0, void 0).ser(se_StartBgpFailoverTestCommand).de(de_StartBgpFailoverTestCommand).build() {
+};
+__name(_StartBgpFailoverTestCommand, "StartBgpFailoverTestCommand");
+var StartBgpFailoverTestCommand = _StartBgpFailoverTestCommand;
+
+// src/commands/StopBgpFailoverTestCommand.ts
+
+
+
+
+var _StopBgpFailoverTestCommand = class _StopBgpFailoverTestCommand 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("OvertureService", "StopBgpFailoverTest", {}).n("DirectConnectClient", "StopBgpFailoverTestCommand").f(void 0, void 0).ser(se_StopBgpFailoverTestCommand).de(de_StopBgpFailoverTestCommand).build() {
+};
+__name(_StopBgpFailoverTestCommand, "StopBgpFailoverTestCommand");
+var StopBgpFailoverTestCommand = _StopBgpFailoverTestCommand;
+
+// 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("OvertureService", "TagResource", {}).n("DirectConnectClient", "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("OvertureService", "UntagResource", {}).n("DirectConnectClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateConnectionCommand.ts
+
+
+
+
+var _UpdateConnectionCommand = class _UpdateConnectionCommand 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("OvertureService", "UpdateConnection", {}).n("DirectConnectClient", "UpdateConnectionCommand").f(void 0, void 0).ser(se_UpdateConnectionCommand).de(de_UpdateConnectionCommand).build() {
+};
+__name(_UpdateConnectionCommand, "UpdateConnectionCommand");
+var UpdateConnectionCommand = _UpdateConnectionCommand;
+
+// src/commands/UpdateDirectConnectGatewayAssociationCommand.ts
+
+
+
+
+var _UpdateDirectConnectGatewayAssociationCommand = class _UpdateDirectConnectGatewayAssociationCommand 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("OvertureService", "UpdateDirectConnectGatewayAssociation", {}).n("DirectConnectClient", "UpdateDirectConnectGatewayAssociationCommand").f(void 0, void 0).ser(se_UpdateDirectConnectGatewayAssociationCommand).de(de_UpdateDirectConnectGatewayAssociationCommand).build() {
+};
+__name(_UpdateDirectConnectGatewayAssociationCommand, "UpdateDirectConnectGatewayAssociationCommand");
+var UpdateDirectConnectGatewayAssociationCommand = _UpdateDirectConnectGatewayAssociationCommand;
+
+// src/commands/UpdateDirectConnectGatewayCommand.ts
+
+
+
+
+var _UpdateDirectConnectGatewayCommand = class _UpdateDirectConnectGatewayCommand 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("OvertureService", "UpdateDirectConnectGateway", {}).n("DirectConnectClient", "UpdateDirectConnectGatewayCommand").f(void 0, void 0).ser(se_UpdateDirectConnectGatewayCommand).de(de_UpdateDirectConnectGatewayCommand).build() {
+};
+__name(_UpdateDirectConnectGatewayCommand, "UpdateDirectConnectGatewayCommand");
+var UpdateDirectConnectGatewayCommand = _UpdateDirectConnectGatewayCommand;
+
+// src/commands/UpdateLagCommand.ts
+
+
+
+
+var _UpdateLagCommand = class _UpdateLagCommand 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("OvertureService", "UpdateLag", {}).n("DirectConnectClient", "UpdateLagCommand").f(void 0, void 0).ser(se_UpdateLagCommand).de(de_UpdateLagCommand).build() {
+};
+__name(_UpdateLagCommand, "UpdateLagCommand");
+var UpdateLagCommand = _UpdateLagCommand;
+
+// src/commands/UpdateVirtualInterfaceAttributesCommand.ts
+
+
+
+
+var _UpdateVirtualInterfaceAttributesCommand = class _UpdateVirtualInterfaceAttributesCommand 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("OvertureService", "UpdateVirtualInterfaceAttributes", {}).n("DirectConnectClient", "UpdateVirtualInterfaceAttributesCommand").f(void 0, void 0).ser(se_UpdateVirtualInterfaceAttributesCommand).de(de_UpdateVirtualInterfaceAttributesCommand).build() {
+};
+__name(_UpdateVirtualInterfaceAttributesCommand, "UpdateVirtualInterfaceAttributesCommand");
+var UpdateVirtualInterfaceAttributesCommand = _UpdateVirtualInterfaceAttributesCommand;
+
+// src/DirectConnect.ts
+var commands = {
+  AcceptDirectConnectGatewayAssociationProposalCommand,
+  AllocateConnectionOnInterconnectCommand,
+  AllocateHostedConnectionCommand,
+  AllocatePrivateVirtualInterfaceCommand,
+  AllocatePublicVirtualInterfaceCommand,
+  AllocateTransitVirtualInterfaceCommand,
+  AssociateConnectionWithLagCommand,
+  AssociateHostedConnectionCommand,
+  AssociateMacSecKeyCommand,
+  AssociateVirtualInterfaceCommand,
+  ConfirmConnectionCommand,
+  ConfirmCustomerAgreementCommand,
+  ConfirmPrivateVirtualInterfaceCommand,
+  ConfirmPublicVirtualInterfaceCommand,
+  ConfirmTransitVirtualInterfaceCommand,
+  CreateBGPPeerCommand,
+  CreateConnectionCommand,
+  CreateDirectConnectGatewayCommand,
+  CreateDirectConnectGatewayAssociationCommand,
+  CreateDirectConnectGatewayAssociationProposalCommand,
+  CreateInterconnectCommand,
+  CreateLagCommand,
+  CreatePrivateVirtualInterfaceCommand,
+  CreatePublicVirtualInterfaceCommand,
+  CreateTransitVirtualInterfaceCommand,
+  DeleteBGPPeerCommand,
+  DeleteConnectionCommand,
+  DeleteDirectConnectGatewayCommand,
+  DeleteDirectConnectGatewayAssociationCommand,
+  DeleteDirectConnectGatewayAssociationProposalCommand,
+  DeleteInterconnectCommand,
+  DeleteLagCommand,
+  DeleteVirtualInterfaceCommand,
+  DescribeConnectionLoaCommand,
+  DescribeConnectionsCommand,
+  DescribeConnectionsOnInterconnectCommand,
+  DescribeCustomerMetadataCommand,
+  DescribeDirectConnectGatewayAssociationProposalsCommand,
+  DescribeDirectConnectGatewayAssociationsCommand,
+  DescribeDirectConnectGatewayAttachmentsCommand,
+  DescribeDirectConnectGatewaysCommand,
+  DescribeHostedConnectionsCommand,
+  DescribeInterconnectLoaCommand,
+  DescribeInterconnectsCommand,
+  DescribeLagsCommand,
+  DescribeLoaCommand,
+  DescribeLocationsCommand,
+  DescribeRouterConfigurationCommand,
+  DescribeTagsCommand,
+  DescribeVirtualGatewaysCommand,
+  DescribeVirtualInterfacesCommand,
+  DisassociateConnectionFromLagCommand,
+  DisassociateMacSecKeyCommand,
+  ListVirtualInterfaceTestHistoryCommand,
+  StartBgpFailoverTestCommand,
+  StopBgpFailoverTestCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateConnectionCommand,
+  UpdateDirectConnectGatewayCommand,
+  UpdateDirectConnectGatewayAssociationCommand,
+  UpdateLagCommand,
+  UpdateVirtualInterfaceAttributesCommand
+};
+var _DirectConnect = class _DirectConnect extends DirectConnectClient {
+};
+__name(_DirectConnect, "DirectConnect");
+var DirectConnect = _DirectConnect;
+(0, import_smithy_client.createAggregatedClient)(commands, DirectConnect);
+
+// 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 = {
+  AcceptDirectConnectGatewayAssociationProposalCommand,
+  AddressFamily,
+  AllocateConnectionOnInterconnectCommand,
+  AllocateHostedConnectionCommand,
+  AllocatePrivateVirtualInterfaceCommand,
+  AllocatePublicVirtualInterfaceCommand,
+  AllocateTransitVirtualInterfaceCommand,
+  AssociateConnectionWithLagCommand,
+  AssociateHostedConnectionCommand,
+  AssociateMacSecKeyCommand,
+  AssociateVirtualInterfaceCommand,
+  BGPPeerState,
+  BGPStatus,
+  ConfirmConnectionCommand,
+  ConfirmCustomerAgreementCommand,
+  ConfirmPrivateVirtualInterfaceCommand,
+  ConfirmPublicVirtualInterfaceCommand,
+  ConfirmTransitVirtualInterfaceCommand,
+  ConnectionState,
+  CreateBGPPeerCommand,
+  CreateConnectionCommand,
+  CreateDirectConnectGatewayAssociationCommand,
+  CreateDirectConnectGatewayAssociationProposalCommand,
+  CreateDirectConnectGatewayCommand,
+  CreateInterconnectCommand,
+  CreateLagCommand,
+  CreatePrivateVirtualInterfaceCommand,
+  CreatePublicVirtualInterfaceCommand,
+  CreateTransitVirtualInterfaceCommand,
+  DeleteBGPPeerCommand,
+  DeleteConnectionCommand,
+  DeleteDirectConnectGatewayAssociationCommand,
+  DeleteDirectConnectGatewayAssociationProposalCommand,
+  DeleteDirectConnectGatewayCommand,
+  DeleteInterconnectCommand,
+  DeleteLagCommand,
+  DeleteVirtualInterfaceCommand,
+  DescribeConnectionLoaCommand,
+  DescribeConnectionsCommand,
+  DescribeConnectionsOnInterconnectCommand,
+  DescribeCustomerMetadataCommand,
+  DescribeDirectConnectGatewayAssociationProposalsCommand,
+  DescribeDirectConnectGatewayAssociationsCommand,
+  DescribeDirectConnectGatewayAttachmentsCommand,
+  DescribeDirectConnectGatewaysCommand,
+  DescribeHostedConnectionsCommand,
+  DescribeInterconnectLoaCommand,
+  DescribeInterconnectsCommand,
+  DescribeLagsCommand,
+  DescribeLoaCommand,
+  DescribeLocationsCommand,
+  DescribeRouterConfigurationCommand,
+  DescribeTagsCommand,
+  DescribeVirtualGatewaysCommand,
+  DescribeVirtualInterfacesCommand,
+  DirectConnect,
+  DirectConnectClient,
+  DirectConnectClientException,
+  DirectConnectGatewayAssociationProposalState,
+  DirectConnectGatewayAssociationState,
+  DirectConnectGatewayAttachmentState,
+  DirectConnectGatewayAttachmentType,
+  DirectConnectGatewayState,
+  DirectConnectServerException,
+  DirectConnectServiceException,
+  DisassociateConnectionFromLagCommand,
+  DisassociateMacSecKeyCommand,
+  DuplicateTagKeysException,
+  GatewayType,
+  HasLogicalRedundancy,
+  InterconnectState,
+  LagState,
+  ListVirtualInterfaceTestHistoryCommand,
+  LoaContentType,
+  NniPartnerType,
+  StartBgpFailoverTestCommand,
+  StopBgpFailoverTestCommand,
+  TagResourceCommand,
+  TooManyTagsException,
+  UntagResourceCommand,
+  UpdateConnectionCommand,
+  UpdateDirectConnectGatewayAssociationCommand,
+  UpdateDirectConnectGatewayCommand,
+  UpdateLagCommand,
+  UpdateVirtualInterfaceAttributesCommand,
+  VirtualInterfaceState,
+  __Client
+});