@aws-sdk/client-network-firewall 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,3452 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NetworkFirewallServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./NetworkFirewallClient"), exports);
-tslib_1.__exportStar(require("./NetworkFirewall"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var NetworkFirewallServiceException_1 = require("./models/NetworkFirewallServiceException");
-Object.defineProperty(exports, "NetworkFirewallServiceException", { enumerable: true, get: function () { return NetworkFirewallServiceException_1.NetworkFirewallServiceException; } });
+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, {
+  AssociateFirewallPolicyCommand: () => AssociateFirewallPolicyCommand,
+  AssociateSubnetsCommand: () => AssociateSubnetsCommand,
+  AttachmentStatus: () => AttachmentStatus,
+  ConfigurationSyncState: () => ConfigurationSyncState,
+  CreateFirewallCommand: () => CreateFirewallCommand,
+  CreateFirewallPolicyCommand: () => CreateFirewallPolicyCommand,
+  CreateRuleGroupCommand: () => CreateRuleGroupCommand,
+  CreateTLSInspectionConfigurationCommand: () => CreateTLSInspectionConfigurationCommand,
+  DeleteFirewallCommand: () => DeleteFirewallCommand,
+  DeleteFirewallPolicyCommand: () => DeleteFirewallPolicyCommand,
+  DeleteResourcePolicyCommand: () => DeleteResourcePolicyCommand,
+  DeleteRuleGroupCommand: () => DeleteRuleGroupCommand,
+  DeleteTLSInspectionConfigurationCommand: () => DeleteTLSInspectionConfigurationCommand,
+  DescribeFirewallCommand: () => DescribeFirewallCommand,
+  DescribeFirewallPolicyCommand: () => DescribeFirewallPolicyCommand,
+  DescribeLoggingConfigurationCommand: () => DescribeLoggingConfigurationCommand,
+  DescribeResourcePolicyCommand: () => DescribeResourcePolicyCommand,
+  DescribeRuleGroupCommand: () => DescribeRuleGroupCommand,
+  DescribeRuleGroupMetadataCommand: () => DescribeRuleGroupMetadataCommand,
+  DescribeTLSInspectionConfigurationCommand: () => DescribeTLSInspectionConfigurationCommand,
+  DisassociateSubnetsCommand: () => DisassociateSubnetsCommand,
+  EncryptionType: () => EncryptionType,
+  FirewallStatusValue: () => FirewallStatusValue,
+  GeneratedRulesType: () => GeneratedRulesType,
+  IPAddressType: () => IPAddressType,
+  IdentifiedType: () => IdentifiedType,
+  InsufficientCapacityException: () => InsufficientCapacityException,
+  InternalServerError: () => InternalServerError,
+  InvalidOperationException: () => InvalidOperationException,
+  InvalidRequestException: () => InvalidRequestException,
+  InvalidResourcePolicyException: () => InvalidResourcePolicyException,
+  InvalidTokenException: () => InvalidTokenException,
+  LimitExceededException: () => LimitExceededException,
+  ListFirewallPoliciesCommand: () => ListFirewallPoliciesCommand,
+  ListFirewallsCommand: () => ListFirewallsCommand,
+  ListRuleGroupsCommand: () => ListRuleGroupsCommand,
+  ListTLSInspectionConfigurationsCommand: () => ListTLSInspectionConfigurationsCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  LogDestinationPermissionException: () => LogDestinationPermissionException,
+  LogDestinationType: () => LogDestinationType,
+  LogType: () => LogType,
+  NetworkFirewall: () => NetworkFirewall,
+  NetworkFirewallClient: () => NetworkFirewallClient,
+  NetworkFirewallServiceException: () => NetworkFirewallServiceException,
+  OverrideAction: () => OverrideAction,
+  PerObjectSyncStatus: () => PerObjectSyncStatus,
+  PutResourcePolicyCommand: () => PutResourcePolicyCommand,
+  ResourceManagedStatus: () => ResourceManagedStatus,
+  ResourceManagedType: () => ResourceManagedType,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ResourceOwnerCheckException: () => ResourceOwnerCheckException,
+  ResourceStatus: () => ResourceStatus,
+  RevocationCheckAction: () => RevocationCheckAction,
+  RuleGroupType: () => RuleGroupType,
+  RuleOrder: () => RuleOrder,
+  StatefulAction: () => StatefulAction,
+  StatefulRuleDirection: () => StatefulRuleDirection,
+  StatefulRuleProtocol: () => StatefulRuleProtocol,
+  StreamExceptionPolicy: () => StreamExceptionPolicy,
+  TCPFlag: () => TCPFlag,
+  TagResourceCommand: () => TagResourceCommand,
+  TargetType: () => TargetType,
+  ThrottlingException: () => ThrottlingException,
+  UnsupportedOperationException: () => UnsupportedOperationException,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateFirewallDeleteProtectionCommand: () => UpdateFirewallDeleteProtectionCommand,
+  UpdateFirewallDescriptionCommand: () => UpdateFirewallDescriptionCommand,
+  UpdateFirewallEncryptionConfigurationCommand: () => UpdateFirewallEncryptionConfigurationCommand,
+  UpdateFirewallPolicyChangeProtectionCommand: () => UpdateFirewallPolicyChangeProtectionCommand,
+  UpdateFirewallPolicyCommand: () => UpdateFirewallPolicyCommand,
+  UpdateLoggingConfigurationCommand: () => UpdateLoggingConfigurationCommand,
+  UpdateRuleGroupCommand: () => UpdateRuleGroupCommand,
+  UpdateSubnetChangeProtectionCommand: () => UpdateSubnetChangeProtectionCommand,
+  UpdateTLSInspectionConfigurationCommand: () => UpdateTLSInspectionConfigurationCommand,
+  __Client: () => import_smithy_client.Client,
+  paginateListFirewallPolicies: () => paginateListFirewallPolicies,
+  paginateListFirewalls: () => paginateListFirewalls,
+  paginateListRuleGroups: () => paginateListRuleGroups,
+  paginateListTLSInspectionConfigurations: () => paginateListTLSInspectionConfigurations,
+  paginateListTagsForResource: () => paginateListTagsForResource
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/NetworkFirewallClient.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: "network-firewall"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/NetworkFirewallClient.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/NetworkFirewallClient.ts
+var _NetworkFirewallClient = class _NetworkFirewallClient 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(_NetworkFirewallClient, "NetworkFirewallClient");
+var NetworkFirewallClient = _NetworkFirewallClient;
+
+// src/NetworkFirewall.ts
+
+
+// src/commands/AssociateFirewallPolicyCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_0.ts
+
+
+
+// src/models/NetworkFirewallServiceException.ts
+
+var _NetworkFirewallServiceException = class _NetworkFirewallServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _NetworkFirewallServiceException.prototype);
+  }
+};
+__name(_NetworkFirewallServiceException, "NetworkFirewallServiceException");
+var NetworkFirewallServiceException = _NetworkFirewallServiceException;
+
+// src/models/models_0.ts
+var IdentifiedType = {
+  STATELESS_RULE_CONTAINS_TCP_FLAGS: "STATELESS_RULE_CONTAINS_TCP_FLAGS",
+  STATELESS_RULE_FORWARDING_ASYMMETRICALLY: "STATELESS_RULE_FORWARDING_ASYMMETRICALLY"
+};
+var _InternalServerError = class _InternalServerError extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerError",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerError";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerError.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+var _InvalidOperationException = class _InvalidOperationException extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidOperationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidOperationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidOperationException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidOperationException, "InvalidOperationException");
+var InvalidOperationException = _InvalidOperationException;
+var _InvalidRequestException = class _InvalidRequestException extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidRequestException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidRequestException, "InvalidRequestException");
+var InvalidRequestException = _InvalidRequestException;
+var _InvalidTokenException = class _InvalidTokenException extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidTokenException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidTokenException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidTokenException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidTokenException, "InvalidTokenException");
+var InvalidTokenException = _InvalidTokenException;
+var _ResourceNotFoundException = class _ResourceNotFoundException extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var _ThrottlingException = class _ThrottlingException extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var IPAddressType = {
+  DUALSTACK: "DUALSTACK",
+  IPV4: "IPV4",
+  IPV6: "IPV6"
+};
+var _InsufficientCapacityException = class _InsufficientCapacityException extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InsufficientCapacityException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InsufficientCapacityException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InsufficientCapacityException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InsufficientCapacityException, "InsufficientCapacityException");
+var InsufficientCapacityException = _InsufficientCapacityException;
+var AttachmentStatus = {
+  CREATING: "CREATING",
+  DELETING: "DELETING",
+  ERROR: "ERROR",
+  FAILED: "FAILED",
+  READY: "READY",
+  SCALING: "SCALING"
+};
+var RevocationCheckAction = {
+  DROP: "DROP",
+  PASS: "PASS",
+  REJECT: "REJECT"
+};
+var ConfigurationSyncState = {
+  CAPACITY_CONSTRAINED: "CAPACITY_CONSTRAINED",
+  IN_SYNC: "IN_SYNC",
+  PENDING: "PENDING"
+};
+var EncryptionType = {
+  AWS_OWNED_KMS_KEY: "AWS_OWNED_KMS_KEY",
+  CUSTOMER_KMS: "CUSTOMER_KMS"
+};
+var FirewallStatusValue = {
+  DELETING: "DELETING",
+  PROVISIONING: "PROVISIONING",
+  READY: "READY"
+};
+var PerObjectSyncStatus = {
+  CAPACITY_CONSTRAINED: "CAPACITY_CONSTRAINED",
+  IN_SYNC: "IN_SYNC",
+  PENDING: "PENDING"
+};
+var _LimitExceededException = class _LimitExceededException extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LimitExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LimitExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LimitExceededException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_LimitExceededException, "LimitExceededException");
+var LimitExceededException = _LimitExceededException;
+var RuleOrder = {
+  DEFAULT_ACTION_ORDER: "DEFAULT_ACTION_ORDER",
+  STRICT_ORDER: "STRICT_ORDER"
+};
+var StreamExceptionPolicy = {
+  CONTINUE: "CONTINUE",
+  DROP: "DROP",
+  REJECT: "REJECT"
+};
+var OverrideAction = {
+  DROP_TO_ALERT: "DROP_TO_ALERT"
+};
+var ResourceStatus = {
+  ACTIVE: "ACTIVE",
+  DELETING: "DELETING",
+  ERROR: "ERROR"
+};
+var GeneratedRulesType = {
+  ALLOWLIST: "ALLOWLIST",
+  DENYLIST: "DENYLIST"
+};
+var TargetType = {
+  HTTP_HOST: "HTTP_HOST",
+  TLS_SNI: "TLS_SNI"
+};
+var StatefulAction = {
+  ALERT: "ALERT",
+  DROP: "DROP",
+  PASS: "PASS",
+  REJECT: "REJECT"
+};
+var StatefulRuleDirection = {
+  ANY: "ANY",
+  FORWARD: "FORWARD"
+};
+var StatefulRuleProtocol = {
+  ANY: "IP",
+  DCERPC: "DCERPC",
+  DHCP: "DHCP",
+  DNS: "DNS",
+  FTP: "FTP",
+  HTTP: "HTTP",
+  ICMP: "ICMP",
+  IKEV2: "IKEV2",
+  IMAP: "IMAP",
+  KRB5: "KRB5",
+  MSN: "MSN",
+  NTP: "NTP",
+  SMB: "SMB",
+  SMTP: "SMTP",
+  SSH: "SSH",
+  TCP: "TCP",
+  TFTP: "TFTP",
+  TLS: "TLS",
+  UDP: "UDP"
+};
+var TCPFlag = {
+  ACK: "ACK",
+  CWR: "CWR",
+  ECE: "ECE",
+  FIN: "FIN",
+  PSH: "PSH",
+  RST: "RST",
+  SYN: "SYN",
+  URG: "URG"
+};
+var RuleGroupType = {
+  STATEFUL: "STATEFUL",
+  STATELESS: "STATELESS"
+};
+var _UnsupportedOperationException = class _UnsupportedOperationException extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedOperationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedOperationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedOperationException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_UnsupportedOperationException, "UnsupportedOperationException");
+var UnsupportedOperationException = _UnsupportedOperationException;
+var _InvalidResourcePolicyException = class _InvalidResourcePolicyException extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidResourcePolicyException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidResourcePolicyException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidResourcePolicyException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidResourcePolicyException, "InvalidResourcePolicyException");
+var InvalidResourcePolicyException = _InvalidResourcePolicyException;
+var LogDestinationType = {
+  CLOUDWATCH_LOGS: "CloudWatchLogs",
+  KINESIS_DATA_FIREHOSE: "KinesisDataFirehose",
+  S3: "S3"
+};
+var LogType = {
+  ALERT: "ALERT",
+  FLOW: "FLOW"
+};
+var ResourceManagedType = {
+  AWS_MANAGED_DOMAIN_LISTS: "AWS_MANAGED_DOMAIN_LISTS",
+  AWS_MANAGED_THREAT_SIGNATURES: "AWS_MANAGED_THREAT_SIGNATURES"
+};
+var ResourceManagedStatus = {
+  ACCOUNT: "ACCOUNT",
+  MANAGED: "MANAGED"
+};
+var _LogDestinationPermissionException = class _LogDestinationPermissionException extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LogDestinationPermissionException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LogDestinationPermissionException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LogDestinationPermissionException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_LogDestinationPermissionException, "LogDestinationPermissionException");
+var LogDestinationPermissionException = _LogDestinationPermissionException;
+var _ResourceOwnerCheckException = class _ResourceOwnerCheckException extends NetworkFirewallServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceOwnerCheckException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceOwnerCheckException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceOwnerCheckException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ResourceOwnerCheckException, "ResourceOwnerCheckException");
+var ResourceOwnerCheckException = _ResourceOwnerCheckException;
+
+// src/protocols/Aws_json1_0.ts
+var se_AssociateFirewallPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateFirewallPolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateFirewallPolicyCommand");
+var se_AssociateSubnetsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AssociateSubnets");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AssociateSubnetsCommand");
+var se_CreateFirewallCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateFirewall");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateFirewallCommand");
+var se_CreateFirewallPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateFirewallPolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateFirewallPolicyCommand");
+var se_CreateRuleGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateRuleGroup");
+  let body;
+  body = JSON.stringify(se_CreateRuleGroupRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateRuleGroupCommand");
+var se_CreateTLSInspectionConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateTLSInspectionConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateTLSInspectionConfigurationCommand");
+var se_DeleteFirewallCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteFirewall");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteFirewallCommand");
+var se_DeleteFirewallPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteFirewallPolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteFirewallPolicyCommand");
+var se_DeleteResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteResourcePolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteResourcePolicyCommand");
+var se_DeleteRuleGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteRuleGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteRuleGroupCommand");
+var se_DeleteTLSInspectionConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteTLSInspectionConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteTLSInspectionConfigurationCommand");
+var se_DescribeFirewallCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeFirewall");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeFirewallCommand");
+var se_DescribeFirewallPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeFirewallPolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeFirewallPolicyCommand");
+var se_DescribeLoggingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeLoggingConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeLoggingConfigurationCommand");
+var se_DescribeResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeResourcePolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeResourcePolicyCommand");
+var se_DescribeRuleGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeRuleGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeRuleGroupCommand");
+var se_DescribeRuleGroupMetadataCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeRuleGroupMetadata");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeRuleGroupMetadataCommand");
+var se_DescribeTLSInspectionConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeTLSInspectionConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeTLSInspectionConfigurationCommand");
+var se_DisassociateSubnetsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DisassociateSubnets");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisassociateSubnetsCommand");
+var se_ListFirewallPoliciesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListFirewallPolicies");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListFirewallPoliciesCommand");
+var se_ListFirewallsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListFirewalls");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListFirewallsCommand");
+var se_ListRuleGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListRuleGroups");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListRuleGroupsCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTagsForResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTagsForResourceCommand");
+var se_ListTLSInspectionConfigurationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTLSInspectionConfigurations");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTLSInspectionConfigurationsCommand");
+var se_PutResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("PutResourcePolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_PutResourcePolicyCommand");
+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_UpdateFirewallDeleteProtectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateFirewallDeleteProtection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateFirewallDeleteProtectionCommand");
+var se_UpdateFirewallDescriptionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateFirewallDescription");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateFirewallDescriptionCommand");
+var se_UpdateFirewallEncryptionConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateFirewallEncryptionConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateFirewallEncryptionConfigurationCommand");
+var se_UpdateFirewallPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateFirewallPolicy");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateFirewallPolicyCommand");
+var se_UpdateFirewallPolicyChangeProtectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateFirewallPolicyChangeProtection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateFirewallPolicyChangeProtectionCommand");
+var se_UpdateLoggingConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateLoggingConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateLoggingConfigurationCommand");
+var se_UpdateRuleGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateRuleGroup");
+  let body;
+  body = JSON.stringify(se_UpdateRuleGroupRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateRuleGroupCommand");
+var se_UpdateSubnetChangeProtectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateSubnetChangeProtection");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateSubnetChangeProtectionCommand");
+var se_UpdateTLSInspectionConfigurationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateTLSInspectionConfiguration");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateTLSInspectionConfigurationCommand");
+var de_AssociateFirewallPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateFirewallPolicyCommandError(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_AssociateFirewallPolicyCommand");
+var de_AssociateFirewallPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.networkfirewall#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateFirewallPolicyCommandError");
+var de_AssociateSubnetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AssociateSubnetsCommandError(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_AssociateSubnetsCommand");
+var de_AssociateSubnetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InsufficientCapacityException":
+    case "com.amazonaws.networkfirewall#InsufficientCapacityException":
+      throw await de_InsufficientCapacityExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.networkfirewall#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AssociateSubnetsCommandError");
+var de_CreateFirewallCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateFirewallCommandError(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_CreateFirewallCommand");
+var de_CreateFirewallCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InsufficientCapacityException":
+    case "com.amazonaws.networkfirewall#InsufficientCapacityException":
+      throw await de_InsufficientCapacityExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.networkfirewall#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.networkfirewall#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateFirewallCommandError");
+var de_CreateFirewallPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateFirewallPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateFirewallPolicyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateFirewallPolicyCommand");
+var de_CreateFirewallPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InsufficientCapacityException":
+    case "com.amazonaws.networkfirewall#InsufficientCapacityException":
+      throw await de_InsufficientCapacityExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.networkfirewall#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateFirewallPolicyCommandError");
+var de_CreateRuleGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateRuleGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateRuleGroupResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateRuleGroupCommand");
+var de_CreateRuleGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InsufficientCapacityException":
+    case "com.amazonaws.networkfirewall#InsufficientCapacityException":
+      throw await de_InsufficientCapacityExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.networkfirewall#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateRuleGroupCommandError");
+var de_CreateTLSInspectionConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateTLSInspectionConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateTLSInspectionConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateTLSInspectionConfigurationCommand");
+var de_CreateTLSInspectionConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InsufficientCapacityException":
+    case "com.amazonaws.networkfirewall#InsufficientCapacityException":
+      throw await de_InsufficientCapacityExceptionRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "LimitExceededException":
+    case "com.amazonaws.networkfirewall#LimitExceededException":
+      throw await de_LimitExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateTLSInspectionConfigurationCommandError");
+var de_DeleteFirewallCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteFirewallCommandError(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_DeleteFirewallCommand");
+var de_DeleteFirewallCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.networkfirewall#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.networkfirewall#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteFirewallCommandError");
+var de_DeleteFirewallPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteFirewallPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteFirewallPolicyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteFirewallPolicyCommand");
+var de_DeleteFirewallPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.networkfirewall#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.networkfirewall#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteFirewallPolicyCommandError");
+var de_DeleteResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteResourcePolicyCommandError(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_DeleteResourcePolicyCommand");
+var de_DeleteResourcePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidResourcePolicyException":
+    case "com.amazonaws.networkfirewall#InvalidResourcePolicyException":
+      throw await de_InvalidResourcePolicyExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteResourcePolicyCommandError");
+var de_DeleteRuleGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteRuleGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteRuleGroupResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteRuleGroupCommand");
+var de_DeleteRuleGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.networkfirewall#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "UnsupportedOperationException":
+    case "com.amazonaws.networkfirewall#UnsupportedOperationException":
+      throw await de_UnsupportedOperationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteRuleGroupCommandError");
+var de_DeleteTLSInspectionConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteTLSInspectionConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteTLSInspectionConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteTLSInspectionConfigurationCommand");
+var de_DeleteTLSInspectionConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.networkfirewall#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteTLSInspectionConfigurationCommandError");
+var de_DescribeFirewallCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeFirewallCommandError(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_DescribeFirewallCommand");
+var de_DescribeFirewallCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeFirewallCommandError");
+var de_DescribeFirewallPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeFirewallPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeFirewallPolicyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeFirewallPolicyCommand");
+var de_DescribeFirewallPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeFirewallPolicyCommandError");
+var de_DescribeLoggingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeLoggingConfigurationCommandError(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_DescribeLoggingConfigurationCommand");
+var de_DescribeLoggingConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeLoggingConfigurationCommandError");
+var de_DescribeResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeResourcePolicyCommandError(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_DescribeResourcePolicyCommand");
+var de_DescribeResourcePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeResourcePolicyCommandError");
+var de_DescribeRuleGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeRuleGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeRuleGroupResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeRuleGroupCommand");
+var de_DescribeRuleGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeRuleGroupCommandError");
+var de_DescribeRuleGroupMetadataCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeRuleGroupMetadataCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeRuleGroupMetadataResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeRuleGroupMetadataCommand");
+var de_DescribeRuleGroupMetadataCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeRuleGroupMetadataCommandError");
+var de_DescribeTLSInspectionConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeTLSInspectionConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeTLSInspectionConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeTLSInspectionConfigurationCommand");
+var de_DescribeTLSInspectionConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeTLSInspectionConfigurationCommandError");
+var de_DisassociateSubnetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisassociateSubnetsCommandError(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_DisassociateSubnetsCommand");
+var de_DisassociateSubnetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidOperationException":
+    case "com.amazonaws.networkfirewall#InvalidOperationException":
+      throw await de_InvalidOperationExceptionRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisassociateSubnetsCommandError");
+var de_ListFirewallPoliciesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListFirewallPoliciesCommandError(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_ListFirewallPoliciesCommand");
+var de_ListFirewallPoliciesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListFirewallPoliciesCommandError");
+var de_ListFirewallsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListFirewallsCommandError(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_ListFirewallsCommand");
+var de_ListFirewallsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListFirewallsCommandError");
+var de_ListRuleGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListRuleGroupsCommandError(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_ListRuleGroupsCommand");
+var de_ListRuleGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListRuleGroupsCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(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_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ListTLSInspectionConfigurationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTLSInspectionConfigurationsCommandError(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_ListTLSInspectionConfigurationsCommand");
+var de_ListTLSInspectionConfigurationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTLSInspectionConfigurationsCommandError");
+var de_PutResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_PutResourcePolicyCommandError(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_PutResourcePolicyCommand");
+var de_PutResourcePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidResourcePolicyException":
+    case "com.amazonaws.networkfirewall#InvalidResourcePolicyException":
+      throw await de_InvalidResourcePolicyExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutResourcePolicyCommandError");
+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 "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(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 "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateFirewallDeleteProtectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateFirewallDeleteProtectionCommandError(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_UpdateFirewallDeleteProtectionCommand");
+var de_UpdateFirewallDeleteProtectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceOwnerCheckException":
+    case "com.amazonaws.networkfirewall#ResourceOwnerCheckException":
+      throw await de_ResourceOwnerCheckExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateFirewallDeleteProtectionCommandError");
+var de_UpdateFirewallDescriptionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateFirewallDescriptionCommandError(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_UpdateFirewallDescriptionCommand");
+var de_UpdateFirewallDescriptionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateFirewallDescriptionCommandError");
+var de_UpdateFirewallEncryptionConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateFirewallEncryptionConfigurationCommandError(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_UpdateFirewallEncryptionConfigurationCommand");
+var de_UpdateFirewallEncryptionConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceOwnerCheckException":
+    case "com.amazonaws.networkfirewall#ResourceOwnerCheckException":
+      throw await de_ResourceOwnerCheckExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateFirewallEncryptionConfigurationCommandError");
+var de_UpdateFirewallPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateFirewallPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateFirewallPolicyResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateFirewallPolicyCommand");
+var de_UpdateFirewallPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateFirewallPolicyCommandError");
+var de_UpdateFirewallPolicyChangeProtectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateFirewallPolicyChangeProtectionCommandError(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_UpdateFirewallPolicyChangeProtectionCommand");
+var de_UpdateFirewallPolicyChangeProtectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceOwnerCheckException":
+    case "com.amazonaws.networkfirewall#ResourceOwnerCheckException":
+      throw await de_ResourceOwnerCheckExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateFirewallPolicyChangeProtectionCommandError");
+var de_UpdateLoggingConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateLoggingConfigurationCommandError(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_UpdateLoggingConfigurationCommand");
+var de_UpdateLoggingConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "LogDestinationPermissionException":
+    case "com.amazonaws.networkfirewall#LogDestinationPermissionException":
+      throw await de_LogDestinationPermissionExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateLoggingConfigurationCommandError");
+var de_UpdateRuleGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateRuleGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateRuleGroupResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateRuleGroupCommand");
+var de_UpdateRuleGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateRuleGroupCommandError");
+var de_UpdateSubnetChangeProtectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateSubnetChangeProtectionCommandError(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_UpdateSubnetChangeProtectionCommand");
+var de_UpdateSubnetChangeProtectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ResourceOwnerCheckException":
+    case "com.amazonaws.networkfirewall#ResourceOwnerCheckException":
+      throw await de_ResourceOwnerCheckExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateSubnetChangeProtectionCommandError");
+var de_UpdateTLSInspectionConfigurationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateTLSInspectionConfigurationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateTLSInspectionConfigurationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateTLSInspectionConfigurationCommand");
+var de_UpdateTLSInspectionConfigurationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.networkfirewall#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "InvalidRequestException":
+    case "com.amazonaws.networkfirewall#InvalidRequestException":
+      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
+    case "InvalidTokenException":
+    case "com.amazonaws.networkfirewall#InvalidTokenException":
+      throw await de_InvalidTokenExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.networkfirewall#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.networkfirewall#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateTLSInspectionConfigurationCommandError");
+var de_InsufficientCapacityExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InsufficientCapacityException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InsufficientCapacityExceptionRes");
+var de_InternalServerErrorRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InternalServerError({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalServerErrorRes");
+var de_InvalidOperationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidOperationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidOperationExceptionRes");
+var de_InvalidRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidRequestExceptionRes");
+var de_InvalidResourcePolicyExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidResourcePolicyException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidResourcePolicyExceptionRes");
+var de_InvalidTokenExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidTokenException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidTokenExceptionRes");
+var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LimitExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LimitExceededExceptionRes");
+var de_LogDestinationPermissionExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new LogDestinationPermissionException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LogDestinationPermissionExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ResourceOwnerCheckExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ResourceOwnerCheckException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ResourceOwnerCheckExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ThrottlingExceptionRes");
+var de_UnsupportedOperationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnsupportedOperationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnsupportedOperationExceptionRes");
+var se_CreateRuleGroupRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AnalyzeRuleGroup: [],
+    Capacity: [],
+    Description: [],
+    DryRun: [],
+    EncryptionConfiguration: import_smithy_client._json,
+    RuleGroup: import_smithy_client._json,
+    RuleGroupName: [],
+    Rules: [],
+    SourceMetadata: import_smithy_client._json,
+    Tags: import_smithy_client._json,
+    Type: []
+  });
+}, "se_CreateRuleGroupRequest");
+var se_UpdateRuleGroupRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    AnalyzeRuleGroup: [],
+    Description: [],
+    DryRun: [],
+    EncryptionConfiguration: import_smithy_client._json,
+    RuleGroup: import_smithy_client._json,
+    RuleGroupArn: [],
+    RuleGroupName: [],
+    Rules: [],
+    SourceMetadata: import_smithy_client._json,
+    Type: [],
+    UpdateToken: []
+  });
+}, "se_UpdateRuleGroupRequest");
+var de_CreateFirewallPolicyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FirewallPolicyResponse: (_) => de_FirewallPolicyResponse(_, context),
+    UpdateToken: import_smithy_client.expectString
+  });
+}, "de_CreateFirewallPolicyResponse");
+var de_CreateRuleGroupResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    RuleGroupResponse: (_) => de_RuleGroupResponse(_, context),
+    UpdateToken: import_smithy_client.expectString
+  });
+}, "de_CreateRuleGroupResponse");
+var de_CreateTLSInspectionConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    TLSInspectionConfigurationResponse: (_) => de_TLSInspectionConfigurationResponse(_, context),
+    UpdateToken: import_smithy_client.expectString
+  });
+}, "de_CreateTLSInspectionConfigurationResponse");
+var de_DeleteFirewallPolicyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FirewallPolicyResponse: (_) => de_FirewallPolicyResponse(_, context)
+  });
+}, "de_DeleteFirewallPolicyResponse");
+var de_DeleteRuleGroupResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    RuleGroupResponse: (_) => de_RuleGroupResponse(_, context)
+  });
+}, "de_DeleteRuleGroupResponse");
+var de_DeleteTLSInspectionConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    TLSInspectionConfigurationResponse: (_) => de_TLSInspectionConfigurationResponse(_, context)
+  });
+}, "de_DeleteTLSInspectionConfigurationResponse");
+var de_DescribeFirewallPolicyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FirewallPolicy: import_smithy_client._json,
+    FirewallPolicyResponse: (_) => de_FirewallPolicyResponse(_, context),
+    UpdateToken: import_smithy_client.expectString
+  });
+}, "de_DescribeFirewallPolicyResponse");
+var de_DescribeRuleGroupMetadataResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Capacity: import_smithy_client.expectInt32,
+    Description: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    RuleGroupArn: import_smithy_client.expectString,
+    RuleGroupName: import_smithy_client.expectString,
+    StatefulRuleOptions: import_smithy_client._json,
+    Type: import_smithy_client.expectString
+  });
+}, "de_DescribeRuleGroupMetadataResponse");
+var de_DescribeRuleGroupResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    RuleGroup: import_smithy_client._json,
+    RuleGroupResponse: (_) => de_RuleGroupResponse(_, context),
+    UpdateToken: import_smithy_client.expectString
+  });
+}, "de_DescribeRuleGroupResponse");
+var de_DescribeTLSInspectionConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    TLSInspectionConfiguration: import_smithy_client._json,
+    TLSInspectionConfigurationResponse: (_) => de_TLSInspectionConfigurationResponse(_, context),
+    UpdateToken: import_smithy_client.expectString
+  });
+}, "de_DescribeTLSInspectionConfigurationResponse");
+var de_FirewallPolicyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ConsumedStatefulRuleCapacity: import_smithy_client.expectInt32,
+    ConsumedStatelessRuleCapacity: import_smithy_client.expectInt32,
+    Description: import_smithy_client.expectString,
+    EncryptionConfiguration: import_smithy_client._json,
+    FirewallPolicyArn: import_smithy_client.expectString,
+    FirewallPolicyId: import_smithy_client.expectString,
+    FirewallPolicyName: import_smithy_client.expectString,
+    FirewallPolicyStatus: import_smithy_client.expectString,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NumberOfAssociations: import_smithy_client.expectInt32,
+    Tags: import_smithy_client._json
+  });
+}, "de_FirewallPolicyResponse");
+var de_RuleGroupResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AnalysisResults: import_smithy_client._json,
+    Capacity: import_smithy_client.expectInt32,
+    ConsumedCapacity: import_smithy_client.expectInt32,
+    Description: import_smithy_client.expectString,
+    EncryptionConfiguration: import_smithy_client._json,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NumberOfAssociations: import_smithy_client.expectInt32,
+    RuleGroupArn: import_smithy_client.expectString,
+    RuleGroupId: import_smithy_client.expectString,
+    RuleGroupName: import_smithy_client.expectString,
+    RuleGroupStatus: import_smithy_client.expectString,
+    SnsTopic: import_smithy_client.expectString,
+    SourceMetadata: import_smithy_client._json,
+    Tags: import_smithy_client._json,
+    Type: import_smithy_client.expectString
+  });
+}, "de_RuleGroupResponse");
+var de_TLSInspectionConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    CertificateAuthority: import_smithy_client._json,
+    Certificates: import_smithy_client._json,
+    Description: import_smithy_client.expectString,
+    EncryptionConfiguration: import_smithy_client._json,
+    LastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NumberOfAssociations: import_smithy_client.expectInt32,
+    TLSInspectionConfigurationArn: import_smithy_client.expectString,
+    TLSInspectionConfigurationId: import_smithy_client.expectString,
+    TLSInspectionConfigurationName: import_smithy_client.expectString,
+    TLSInspectionConfigurationStatus: import_smithy_client.expectString,
+    Tags: import_smithy_client._json
+  });
+}, "de_TLSInspectionConfigurationResponse");
+var de_UpdateFirewallPolicyResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    FirewallPolicyResponse: (_) => de_FirewallPolicyResponse(_, context),
+    UpdateToken: import_smithy_client.expectString
+  });
+}, "de_UpdateFirewallPolicyResponse");
+var de_UpdateRuleGroupResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    RuleGroupResponse: (_) => de_RuleGroupResponse(_, context),
+    UpdateToken: import_smithy_client.expectString
+  });
+}, "de_UpdateRuleGroupResponse");
+var de_UpdateTLSInspectionConfigurationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    TLSInspectionConfigurationResponse: (_) => de_TLSInspectionConfigurationResponse(_, context),
+    UpdateToken: import_smithy_client.expectString
+  });
+}, "de_UpdateTLSInspectionConfigurationResponse");
+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)(NetworkFirewallServiceException);
+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.0",
+    "x-amz-target": `NetworkFirewall_20201112.${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/AssociateFirewallPolicyCommand.ts
+var _AssociateFirewallPolicyCommand = class _AssociateFirewallPolicyCommand 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("NetworkFirewall_20201112", "AssociateFirewallPolicy", {}).n("NetworkFirewallClient", "AssociateFirewallPolicyCommand").f(void 0, void 0).ser(se_AssociateFirewallPolicyCommand).de(de_AssociateFirewallPolicyCommand).build() {
+};
+__name(_AssociateFirewallPolicyCommand, "AssociateFirewallPolicyCommand");
+var AssociateFirewallPolicyCommand = _AssociateFirewallPolicyCommand;
+
+// src/commands/AssociateSubnetsCommand.ts
+
+
+
+
+var _AssociateSubnetsCommand = class _AssociateSubnetsCommand 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("NetworkFirewall_20201112", "AssociateSubnets", {}).n("NetworkFirewallClient", "AssociateSubnetsCommand").f(void 0, void 0).ser(se_AssociateSubnetsCommand).de(de_AssociateSubnetsCommand).build() {
+};
+__name(_AssociateSubnetsCommand, "AssociateSubnetsCommand");
+var AssociateSubnetsCommand = _AssociateSubnetsCommand;
+
+// src/commands/CreateFirewallCommand.ts
+
+
+
+
+var _CreateFirewallCommand = class _CreateFirewallCommand 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("NetworkFirewall_20201112", "CreateFirewall", {}).n("NetworkFirewallClient", "CreateFirewallCommand").f(void 0, void 0).ser(se_CreateFirewallCommand).de(de_CreateFirewallCommand).build() {
+};
+__name(_CreateFirewallCommand, "CreateFirewallCommand");
+var CreateFirewallCommand = _CreateFirewallCommand;
+
+// src/commands/CreateFirewallPolicyCommand.ts
+
+
+
+
+var _CreateFirewallPolicyCommand = class _CreateFirewallPolicyCommand 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("NetworkFirewall_20201112", "CreateFirewallPolicy", {}).n("NetworkFirewallClient", "CreateFirewallPolicyCommand").f(void 0, void 0).ser(se_CreateFirewallPolicyCommand).de(de_CreateFirewallPolicyCommand).build() {
+};
+__name(_CreateFirewallPolicyCommand, "CreateFirewallPolicyCommand");
+var CreateFirewallPolicyCommand = _CreateFirewallPolicyCommand;
+
+// src/commands/CreateRuleGroupCommand.ts
+
+
+
+
+var _CreateRuleGroupCommand = class _CreateRuleGroupCommand 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("NetworkFirewall_20201112", "CreateRuleGroup", {}).n("NetworkFirewallClient", "CreateRuleGroupCommand").f(void 0, void 0).ser(se_CreateRuleGroupCommand).de(de_CreateRuleGroupCommand).build() {
+};
+__name(_CreateRuleGroupCommand, "CreateRuleGroupCommand");
+var CreateRuleGroupCommand = _CreateRuleGroupCommand;
+
+// src/commands/CreateTLSInspectionConfigurationCommand.ts
+
+
+
+
+var _CreateTLSInspectionConfigurationCommand = class _CreateTLSInspectionConfigurationCommand 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("NetworkFirewall_20201112", "CreateTLSInspectionConfiguration", {}).n("NetworkFirewallClient", "CreateTLSInspectionConfigurationCommand").f(void 0, void 0).ser(se_CreateTLSInspectionConfigurationCommand).de(de_CreateTLSInspectionConfigurationCommand).build() {
+};
+__name(_CreateTLSInspectionConfigurationCommand, "CreateTLSInspectionConfigurationCommand");
+var CreateTLSInspectionConfigurationCommand = _CreateTLSInspectionConfigurationCommand;
+
+// src/commands/DeleteFirewallCommand.ts
+
+
+
+
+var _DeleteFirewallCommand = class _DeleteFirewallCommand 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("NetworkFirewall_20201112", "DeleteFirewall", {}).n("NetworkFirewallClient", "DeleteFirewallCommand").f(void 0, void 0).ser(se_DeleteFirewallCommand).de(de_DeleteFirewallCommand).build() {
+};
+__name(_DeleteFirewallCommand, "DeleteFirewallCommand");
+var DeleteFirewallCommand = _DeleteFirewallCommand;
+
+// src/commands/DeleteFirewallPolicyCommand.ts
+
+
+
+
+var _DeleteFirewallPolicyCommand = class _DeleteFirewallPolicyCommand 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("NetworkFirewall_20201112", "DeleteFirewallPolicy", {}).n("NetworkFirewallClient", "DeleteFirewallPolicyCommand").f(void 0, void 0).ser(se_DeleteFirewallPolicyCommand).de(de_DeleteFirewallPolicyCommand).build() {
+};
+__name(_DeleteFirewallPolicyCommand, "DeleteFirewallPolicyCommand");
+var DeleteFirewallPolicyCommand = _DeleteFirewallPolicyCommand;
+
+// src/commands/DeleteResourcePolicyCommand.ts
+
+
+
+
+var _DeleteResourcePolicyCommand = class _DeleteResourcePolicyCommand 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("NetworkFirewall_20201112", "DeleteResourcePolicy", {}).n("NetworkFirewallClient", "DeleteResourcePolicyCommand").f(void 0, void 0).ser(se_DeleteResourcePolicyCommand).de(de_DeleteResourcePolicyCommand).build() {
+};
+__name(_DeleteResourcePolicyCommand, "DeleteResourcePolicyCommand");
+var DeleteResourcePolicyCommand = _DeleteResourcePolicyCommand;
+
+// src/commands/DeleteRuleGroupCommand.ts
+
+
+
+
+var _DeleteRuleGroupCommand = class _DeleteRuleGroupCommand 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("NetworkFirewall_20201112", "DeleteRuleGroup", {}).n("NetworkFirewallClient", "DeleteRuleGroupCommand").f(void 0, void 0).ser(se_DeleteRuleGroupCommand).de(de_DeleteRuleGroupCommand).build() {
+};
+__name(_DeleteRuleGroupCommand, "DeleteRuleGroupCommand");
+var DeleteRuleGroupCommand = _DeleteRuleGroupCommand;
+
+// src/commands/DeleteTLSInspectionConfigurationCommand.ts
+
+
+
+
+var _DeleteTLSInspectionConfigurationCommand = class _DeleteTLSInspectionConfigurationCommand 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("NetworkFirewall_20201112", "DeleteTLSInspectionConfiguration", {}).n("NetworkFirewallClient", "DeleteTLSInspectionConfigurationCommand").f(void 0, void 0).ser(se_DeleteTLSInspectionConfigurationCommand).de(de_DeleteTLSInspectionConfigurationCommand).build() {
+};
+__name(_DeleteTLSInspectionConfigurationCommand, "DeleteTLSInspectionConfigurationCommand");
+var DeleteTLSInspectionConfigurationCommand = _DeleteTLSInspectionConfigurationCommand;
+
+// src/commands/DescribeFirewallCommand.ts
+
+
+
+
+var _DescribeFirewallCommand = class _DescribeFirewallCommand 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("NetworkFirewall_20201112", "DescribeFirewall", {}).n("NetworkFirewallClient", "DescribeFirewallCommand").f(void 0, void 0).ser(se_DescribeFirewallCommand).de(de_DescribeFirewallCommand).build() {
+};
+__name(_DescribeFirewallCommand, "DescribeFirewallCommand");
+var DescribeFirewallCommand = _DescribeFirewallCommand;
+
+// src/commands/DescribeFirewallPolicyCommand.ts
+
+
+
+
+var _DescribeFirewallPolicyCommand = class _DescribeFirewallPolicyCommand 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("NetworkFirewall_20201112", "DescribeFirewallPolicy", {}).n("NetworkFirewallClient", "DescribeFirewallPolicyCommand").f(void 0, void 0).ser(se_DescribeFirewallPolicyCommand).de(de_DescribeFirewallPolicyCommand).build() {
+};
+__name(_DescribeFirewallPolicyCommand, "DescribeFirewallPolicyCommand");
+var DescribeFirewallPolicyCommand = _DescribeFirewallPolicyCommand;
+
+// src/commands/DescribeLoggingConfigurationCommand.ts
+
+
+
+
+var _DescribeLoggingConfigurationCommand = class _DescribeLoggingConfigurationCommand 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("NetworkFirewall_20201112", "DescribeLoggingConfiguration", {}).n("NetworkFirewallClient", "DescribeLoggingConfigurationCommand").f(void 0, void 0).ser(se_DescribeLoggingConfigurationCommand).de(de_DescribeLoggingConfigurationCommand).build() {
+};
+__name(_DescribeLoggingConfigurationCommand, "DescribeLoggingConfigurationCommand");
+var DescribeLoggingConfigurationCommand = _DescribeLoggingConfigurationCommand;
+
+// src/commands/DescribeResourcePolicyCommand.ts
+
+
+
+
+var _DescribeResourcePolicyCommand = class _DescribeResourcePolicyCommand 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("NetworkFirewall_20201112", "DescribeResourcePolicy", {}).n("NetworkFirewallClient", "DescribeResourcePolicyCommand").f(void 0, void 0).ser(se_DescribeResourcePolicyCommand).de(de_DescribeResourcePolicyCommand).build() {
+};
+__name(_DescribeResourcePolicyCommand, "DescribeResourcePolicyCommand");
+var DescribeResourcePolicyCommand = _DescribeResourcePolicyCommand;
+
+// src/commands/DescribeRuleGroupCommand.ts
+
+
+
+
+var _DescribeRuleGroupCommand = class _DescribeRuleGroupCommand 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("NetworkFirewall_20201112", "DescribeRuleGroup", {}).n("NetworkFirewallClient", "DescribeRuleGroupCommand").f(void 0, void 0).ser(se_DescribeRuleGroupCommand).de(de_DescribeRuleGroupCommand).build() {
+};
+__name(_DescribeRuleGroupCommand, "DescribeRuleGroupCommand");
+var DescribeRuleGroupCommand = _DescribeRuleGroupCommand;
+
+// src/commands/DescribeRuleGroupMetadataCommand.ts
+
+
+
+
+var _DescribeRuleGroupMetadataCommand = class _DescribeRuleGroupMetadataCommand 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("NetworkFirewall_20201112", "DescribeRuleGroupMetadata", {}).n("NetworkFirewallClient", "DescribeRuleGroupMetadataCommand").f(void 0, void 0).ser(se_DescribeRuleGroupMetadataCommand).de(de_DescribeRuleGroupMetadataCommand).build() {
+};
+__name(_DescribeRuleGroupMetadataCommand, "DescribeRuleGroupMetadataCommand");
+var DescribeRuleGroupMetadataCommand = _DescribeRuleGroupMetadataCommand;
+
+// src/commands/DescribeTLSInspectionConfigurationCommand.ts
+
+
+
+
+var _DescribeTLSInspectionConfigurationCommand = class _DescribeTLSInspectionConfigurationCommand 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("NetworkFirewall_20201112", "DescribeTLSInspectionConfiguration", {}).n("NetworkFirewallClient", "DescribeTLSInspectionConfigurationCommand").f(void 0, void 0).ser(se_DescribeTLSInspectionConfigurationCommand).de(de_DescribeTLSInspectionConfigurationCommand).build() {
+};
+__name(_DescribeTLSInspectionConfigurationCommand, "DescribeTLSInspectionConfigurationCommand");
+var DescribeTLSInspectionConfigurationCommand = _DescribeTLSInspectionConfigurationCommand;
+
+// src/commands/DisassociateSubnetsCommand.ts
+
+
+
+
+var _DisassociateSubnetsCommand = class _DisassociateSubnetsCommand 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("NetworkFirewall_20201112", "DisassociateSubnets", {}).n("NetworkFirewallClient", "DisassociateSubnetsCommand").f(void 0, void 0).ser(se_DisassociateSubnetsCommand).de(de_DisassociateSubnetsCommand).build() {
+};
+__name(_DisassociateSubnetsCommand, "DisassociateSubnetsCommand");
+var DisassociateSubnetsCommand = _DisassociateSubnetsCommand;
+
+// src/commands/ListFirewallPoliciesCommand.ts
+
+
+
+
+var _ListFirewallPoliciesCommand = class _ListFirewallPoliciesCommand 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("NetworkFirewall_20201112", "ListFirewallPolicies", {}).n("NetworkFirewallClient", "ListFirewallPoliciesCommand").f(void 0, void 0).ser(se_ListFirewallPoliciesCommand).de(de_ListFirewallPoliciesCommand).build() {
+};
+__name(_ListFirewallPoliciesCommand, "ListFirewallPoliciesCommand");
+var ListFirewallPoliciesCommand = _ListFirewallPoliciesCommand;
+
+// src/commands/ListFirewallsCommand.ts
+
+
+
+
+var _ListFirewallsCommand = class _ListFirewallsCommand 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("NetworkFirewall_20201112", "ListFirewalls", {}).n("NetworkFirewallClient", "ListFirewallsCommand").f(void 0, void 0).ser(se_ListFirewallsCommand).de(de_ListFirewallsCommand).build() {
+};
+__name(_ListFirewallsCommand, "ListFirewallsCommand");
+var ListFirewallsCommand = _ListFirewallsCommand;
+
+// src/commands/ListRuleGroupsCommand.ts
+
+
+
+
+var _ListRuleGroupsCommand = class _ListRuleGroupsCommand 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("NetworkFirewall_20201112", "ListRuleGroups", {}).n("NetworkFirewallClient", "ListRuleGroupsCommand").f(void 0, void 0).ser(se_ListRuleGroupsCommand).de(de_ListRuleGroupsCommand).build() {
+};
+__name(_ListRuleGroupsCommand, "ListRuleGroupsCommand");
+var ListRuleGroupsCommand = _ListRuleGroupsCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("NetworkFirewall_20201112", "ListTagsForResource", {}).n("NetworkFirewallClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ListTLSInspectionConfigurationsCommand.ts
+
+
+
+
+var _ListTLSInspectionConfigurationsCommand = class _ListTLSInspectionConfigurationsCommand 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("NetworkFirewall_20201112", "ListTLSInspectionConfigurations", {}).n("NetworkFirewallClient", "ListTLSInspectionConfigurationsCommand").f(void 0, void 0).ser(se_ListTLSInspectionConfigurationsCommand).de(de_ListTLSInspectionConfigurationsCommand).build() {
+};
+__name(_ListTLSInspectionConfigurationsCommand, "ListTLSInspectionConfigurationsCommand");
+var ListTLSInspectionConfigurationsCommand = _ListTLSInspectionConfigurationsCommand;
+
+// src/commands/PutResourcePolicyCommand.ts
+
+
+
+
+var _PutResourcePolicyCommand = class _PutResourcePolicyCommand 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("NetworkFirewall_20201112", "PutResourcePolicy", {}).n("NetworkFirewallClient", "PutResourcePolicyCommand").f(void 0, void 0).ser(se_PutResourcePolicyCommand).de(de_PutResourcePolicyCommand).build() {
+};
+__name(_PutResourcePolicyCommand, "PutResourcePolicyCommand");
+var PutResourcePolicyCommand = _PutResourcePolicyCommand;
+
+// 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("NetworkFirewall_20201112", "TagResource", {}).n("NetworkFirewallClient", "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("NetworkFirewall_20201112", "UntagResource", {}).n("NetworkFirewallClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateFirewallDeleteProtectionCommand.ts
+
+
+
+
+var _UpdateFirewallDeleteProtectionCommand = class _UpdateFirewallDeleteProtectionCommand 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("NetworkFirewall_20201112", "UpdateFirewallDeleteProtection", {}).n("NetworkFirewallClient", "UpdateFirewallDeleteProtectionCommand").f(void 0, void 0).ser(se_UpdateFirewallDeleteProtectionCommand).de(de_UpdateFirewallDeleteProtectionCommand).build() {
+};
+__name(_UpdateFirewallDeleteProtectionCommand, "UpdateFirewallDeleteProtectionCommand");
+var UpdateFirewallDeleteProtectionCommand = _UpdateFirewallDeleteProtectionCommand;
+
+// src/commands/UpdateFirewallDescriptionCommand.ts
+
+
+
+
+var _UpdateFirewallDescriptionCommand = class _UpdateFirewallDescriptionCommand 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("NetworkFirewall_20201112", "UpdateFirewallDescription", {}).n("NetworkFirewallClient", "UpdateFirewallDescriptionCommand").f(void 0, void 0).ser(se_UpdateFirewallDescriptionCommand).de(de_UpdateFirewallDescriptionCommand).build() {
+};
+__name(_UpdateFirewallDescriptionCommand, "UpdateFirewallDescriptionCommand");
+var UpdateFirewallDescriptionCommand = _UpdateFirewallDescriptionCommand;
+
+// src/commands/UpdateFirewallEncryptionConfigurationCommand.ts
+
+
+
+
+var _UpdateFirewallEncryptionConfigurationCommand = class _UpdateFirewallEncryptionConfigurationCommand 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("NetworkFirewall_20201112", "UpdateFirewallEncryptionConfiguration", {}).n("NetworkFirewallClient", "UpdateFirewallEncryptionConfigurationCommand").f(void 0, void 0).ser(se_UpdateFirewallEncryptionConfigurationCommand).de(de_UpdateFirewallEncryptionConfigurationCommand).build() {
+};
+__name(_UpdateFirewallEncryptionConfigurationCommand, "UpdateFirewallEncryptionConfigurationCommand");
+var UpdateFirewallEncryptionConfigurationCommand = _UpdateFirewallEncryptionConfigurationCommand;
+
+// src/commands/UpdateFirewallPolicyChangeProtectionCommand.ts
+
+
+
+
+var _UpdateFirewallPolicyChangeProtectionCommand = class _UpdateFirewallPolicyChangeProtectionCommand 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("NetworkFirewall_20201112", "UpdateFirewallPolicyChangeProtection", {}).n("NetworkFirewallClient", "UpdateFirewallPolicyChangeProtectionCommand").f(void 0, void 0).ser(se_UpdateFirewallPolicyChangeProtectionCommand).de(de_UpdateFirewallPolicyChangeProtectionCommand).build() {
+};
+__name(_UpdateFirewallPolicyChangeProtectionCommand, "UpdateFirewallPolicyChangeProtectionCommand");
+var UpdateFirewallPolicyChangeProtectionCommand = _UpdateFirewallPolicyChangeProtectionCommand;
+
+// src/commands/UpdateFirewallPolicyCommand.ts
+
+
+
+
+var _UpdateFirewallPolicyCommand = class _UpdateFirewallPolicyCommand 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("NetworkFirewall_20201112", "UpdateFirewallPolicy", {}).n("NetworkFirewallClient", "UpdateFirewallPolicyCommand").f(void 0, void 0).ser(se_UpdateFirewallPolicyCommand).de(de_UpdateFirewallPolicyCommand).build() {
+};
+__name(_UpdateFirewallPolicyCommand, "UpdateFirewallPolicyCommand");
+var UpdateFirewallPolicyCommand = _UpdateFirewallPolicyCommand;
+
+// src/commands/UpdateLoggingConfigurationCommand.ts
+
+
+
+
+var _UpdateLoggingConfigurationCommand = class _UpdateLoggingConfigurationCommand 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("NetworkFirewall_20201112", "UpdateLoggingConfiguration", {}).n("NetworkFirewallClient", "UpdateLoggingConfigurationCommand").f(void 0, void 0).ser(se_UpdateLoggingConfigurationCommand).de(de_UpdateLoggingConfigurationCommand).build() {
+};
+__name(_UpdateLoggingConfigurationCommand, "UpdateLoggingConfigurationCommand");
+var UpdateLoggingConfigurationCommand = _UpdateLoggingConfigurationCommand;
+
+// src/commands/UpdateRuleGroupCommand.ts
+
+
+
+
+var _UpdateRuleGroupCommand = class _UpdateRuleGroupCommand 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("NetworkFirewall_20201112", "UpdateRuleGroup", {}).n("NetworkFirewallClient", "UpdateRuleGroupCommand").f(void 0, void 0).ser(se_UpdateRuleGroupCommand).de(de_UpdateRuleGroupCommand).build() {
+};
+__name(_UpdateRuleGroupCommand, "UpdateRuleGroupCommand");
+var UpdateRuleGroupCommand = _UpdateRuleGroupCommand;
+
+// src/commands/UpdateSubnetChangeProtectionCommand.ts
+
+
+
+
+var _UpdateSubnetChangeProtectionCommand = class _UpdateSubnetChangeProtectionCommand 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("NetworkFirewall_20201112", "UpdateSubnetChangeProtection", {}).n("NetworkFirewallClient", "UpdateSubnetChangeProtectionCommand").f(void 0, void 0).ser(se_UpdateSubnetChangeProtectionCommand).de(de_UpdateSubnetChangeProtectionCommand).build() {
+};
+__name(_UpdateSubnetChangeProtectionCommand, "UpdateSubnetChangeProtectionCommand");
+var UpdateSubnetChangeProtectionCommand = _UpdateSubnetChangeProtectionCommand;
+
+// src/commands/UpdateTLSInspectionConfigurationCommand.ts
+
+
+
+
+var _UpdateTLSInspectionConfigurationCommand = class _UpdateTLSInspectionConfigurationCommand 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("NetworkFirewall_20201112", "UpdateTLSInspectionConfiguration", {}).n("NetworkFirewallClient", "UpdateTLSInspectionConfigurationCommand").f(void 0, void 0).ser(se_UpdateTLSInspectionConfigurationCommand).de(de_UpdateTLSInspectionConfigurationCommand).build() {
+};
+__name(_UpdateTLSInspectionConfigurationCommand, "UpdateTLSInspectionConfigurationCommand");
+var UpdateTLSInspectionConfigurationCommand = _UpdateTLSInspectionConfigurationCommand;
+
+// src/NetworkFirewall.ts
+var commands = {
+  AssociateFirewallPolicyCommand,
+  AssociateSubnetsCommand,
+  CreateFirewallCommand,
+  CreateFirewallPolicyCommand,
+  CreateRuleGroupCommand,
+  CreateTLSInspectionConfigurationCommand,
+  DeleteFirewallCommand,
+  DeleteFirewallPolicyCommand,
+  DeleteResourcePolicyCommand,
+  DeleteRuleGroupCommand,
+  DeleteTLSInspectionConfigurationCommand,
+  DescribeFirewallCommand,
+  DescribeFirewallPolicyCommand,
+  DescribeLoggingConfigurationCommand,
+  DescribeResourcePolicyCommand,
+  DescribeRuleGroupCommand,
+  DescribeRuleGroupMetadataCommand,
+  DescribeTLSInspectionConfigurationCommand,
+  DisassociateSubnetsCommand,
+  ListFirewallPoliciesCommand,
+  ListFirewallsCommand,
+  ListRuleGroupsCommand,
+  ListTagsForResourceCommand,
+  ListTLSInspectionConfigurationsCommand,
+  PutResourcePolicyCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateFirewallDeleteProtectionCommand,
+  UpdateFirewallDescriptionCommand,
+  UpdateFirewallEncryptionConfigurationCommand,
+  UpdateFirewallPolicyCommand,
+  UpdateFirewallPolicyChangeProtectionCommand,
+  UpdateLoggingConfigurationCommand,
+  UpdateRuleGroupCommand,
+  UpdateSubnetChangeProtectionCommand,
+  UpdateTLSInspectionConfigurationCommand
+};
+var _NetworkFirewall = class _NetworkFirewall extends NetworkFirewallClient {
+};
+__name(_NetworkFirewall, "NetworkFirewall");
+var NetworkFirewall = _NetworkFirewall;
+(0, import_smithy_client.createAggregatedClient)(commands, NetworkFirewall);
+
+// src/pagination/ListFirewallPoliciesPaginator.ts
+var import_core = require("@smithy/core");
+var paginateListFirewallPolicies = (0, import_core.createPaginator)(NetworkFirewallClient, ListFirewallPoliciesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListFirewallsPaginator.ts
+
+var paginateListFirewalls = (0, import_core.createPaginator)(NetworkFirewallClient, ListFirewallsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListRuleGroupsPaginator.ts
+
+var paginateListRuleGroups = (0, import_core.createPaginator)(NetworkFirewallClient, ListRuleGroupsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListTLSInspectionConfigurationsPaginator.ts
+
+var paginateListTLSInspectionConfigurations = (0, import_core.createPaginator)(NetworkFirewallClient, ListTLSInspectionConfigurationsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListTagsForResourcePaginator.ts
+
+var paginateListTagsForResource = (0, import_core.createPaginator)(NetworkFirewallClient, ListTagsForResourceCommand, "NextToken", "NextToken", "MaxResults");
+
+// 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 = {
+  AssociateFirewallPolicyCommand,
+  AssociateSubnetsCommand,
+  AttachmentStatus,
+  ConfigurationSyncState,
+  CreateFirewallCommand,
+  CreateFirewallPolicyCommand,
+  CreateRuleGroupCommand,
+  CreateTLSInspectionConfigurationCommand,
+  DeleteFirewallCommand,
+  DeleteFirewallPolicyCommand,
+  DeleteResourcePolicyCommand,
+  DeleteRuleGroupCommand,
+  DeleteTLSInspectionConfigurationCommand,
+  DescribeFirewallCommand,
+  DescribeFirewallPolicyCommand,
+  DescribeLoggingConfigurationCommand,
+  DescribeResourcePolicyCommand,
+  DescribeRuleGroupCommand,
+  DescribeRuleGroupMetadataCommand,
+  DescribeTLSInspectionConfigurationCommand,
+  DisassociateSubnetsCommand,
+  EncryptionType,
+  FirewallStatusValue,
+  GeneratedRulesType,
+  IPAddressType,
+  IdentifiedType,
+  InsufficientCapacityException,
+  InternalServerError,
+  InvalidOperationException,
+  InvalidRequestException,
+  InvalidResourcePolicyException,
+  InvalidTokenException,
+  LimitExceededException,
+  ListFirewallPoliciesCommand,
+  ListFirewallsCommand,
+  ListRuleGroupsCommand,
+  ListTLSInspectionConfigurationsCommand,
+  ListTagsForResourceCommand,
+  LogDestinationPermissionException,
+  LogDestinationType,
+  LogType,
+  NetworkFirewall,
+  NetworkFirewallClient,
+  NetworkFirewallServiceException,
+  OverrideAction,
+  PerObjectSyncStatus,
+  PutResourcePolicyCommand,
+  ResourceManagedStatus,
+  ResourceManagedType,
+  ResourceNotFoundException,
+  ResourceOwnerCheckException,
+  ResourceStatus,
+  RevocationCheckAction,
+  RuleGroupType,
+  RuleOrder,
+  StatefulAction,
+  StatefulRuleDirection,
+  StatefulRuleProtocol,
+  StreamExceptionPolicy,
+  TCPFlag,
+  TagResourceCommand,
+  TargetType,
+  ThrottlingException,
+  UnsupportedOperationException,
+  UntagResourceCommand,
+  UpdateFirewallDeleteProtectionCommand,
+  UpdateFirewallDescriptionCommand,
+  UpdateFirewallEncryptionConfigurationCommand,
+  UpdateFirewallPolicyChangeProtectionCommand,
+  UpdateFirewallPolicyCommand,
+  UpdateLoggingConfigurationCommand,
+  UpdateRuleGroupCommand,
+  UpdateSubnetChangeProtectionCommand,
+  UpdateTLSInspectionConfigurationCommand,
+  __Client,
+  paginateListFirewallPolicies,
+  paginateListFirewalls,
+  paginateListRuleGroups,
+  paginateListTLSInspectionConfigurations,
+  paginateListTagsForResource
+});