@aws-sdk/client-elastic-load-balancing 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,13 +1,4755 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ElasticLoadBalancingServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./ElasticLoadBalancingClient"), exports);
-tslib_1.__exportStar(require("./ElasticLoadBalancing"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./waiters"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var ElasticLoadBalancingServiceException_1 = require("./models/ElasticLoadBalancingServiceException");
-Object.defineProperty(exports, "ElasticLoadBalancingServiceException", { enumerable: true, get: function () { return ElasticLoadBalancingServiceException_1.ElasticLoadBalancingServiceException; } });
+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, {
+  AccessPointNotFoundException: () => AccessPointNotFoundException,
+  AddTagsCommand: () => AddTagsCommand,
+  ApplySecurityGroupsToLoadBalancerCommand: () => ApplySecurityGroupsToLoadBalancerCommand,
+  AttachLoadBalancerToSubnetsCommand: () => AttachLoadBalancerToSubnetsCommand,
+  CertificateNotFoundException: () => CertificateNotFoundException,
+  ConfigureHealthCheckCommand: () => ConfigureHealthCheckCommand,
+  CreateAppCookieStickinessPolicyCommand: () => CreateAppCookieStickinessPolicyCommand,
+  CreateLBCookieStickinessPolicyCommand: () => CreateLBCookieStickinessPolicyCommand,
+  CreateLoadBalancerCommand: () => CreateLoadBalancerCommand,
+  CreateLoadBalancerListenersCommand: () => CreateLoadBalancerListenersCommand,
+  CreateLoadBalancerPolicyCommand: () => CreateLoadBalancerPolicyCommand,
+  DeleteLoadBalancerCommand: () => DeleteLoadBalancerCommand,
+  DeleteLoadBalancerListenersCommand: () => DeleteLoadBalancerListenersCommand,
+  DeleteLoadBalancerPolicyCommand: () => DeleteLoadBalancerPolicyCommand,
+  DependencyThrottleException: () => DependencyThrottleException,
+  DeregisterInstancesFromLoadBalancerCommand: () => DeregisterInstancesFromLoadBalancerCommand,
+  DescribeAccountLimitsCommand: () => DescribeAccountLimitsCommand,
+  DescribeInstanceHealthCommand: () => DescribeInstanceHealthCommand,
+  DescribeLoadBalancerAttributesCommand: () => DescribeLoadBalancerAttributesCommand,
+  DescribeLoadBalancerPoliciesCommand: () => DescribeLoadBalancerPoliciesCommand,
+  DescribeLoadBalancerPolicyTypesCommand: () => DescribeLoadBalancerPolicyTypesCommand,
+  DescribeLoadBalancersCommand: () => DescribeLoadBalancersCommand,
+  DescribeTagsCommand: () => DescribeTagsCommand,
+  DetachLoadBalancerFromSubnetsCommand: () => DetachLoadBalancerFromSubnetsCommand,
+  DisableAvailabilityZonesForLoadBalancerCommand: () => DisableAvailabilityZonesForLoadBalancerCommand,
+  DuplicateAccessPointNameException: () => DuplicateAccessPointNameException,
+  DuplicateListenerException: () => DuplicateListenerException,
+  DuplicatePolicyNameException: () => DuplicatePolicyNameException,
+  DuplicateTagKeysException: () => DuplicateTagKeysException,
+  ElasticLoadBalancing: () => ElasticLoadBalancing,
+  ElasticLoadBalancingClient: () => ElasticLoadBalancingClient,
+  ElasticLoadBalancingServiceException: () => ElasticLoadBalancingServiceException,
+  EnableAvailabilityZonesForLoadBalancerCommand: () => EnableAvailabilityZonesForLoadBalancerCommand,
+  InvalidConfigurationRequestException: () => InvalidConfigurationRequestException,
+  InvalidEndPointException: () => InvalidEndPointException,
+  InvalidSchemeException: () => InvalidSchemeException,
+  InvalidSecurityGroupException: () => InvalidSecurityGroupException,
+  InvalidSubnetException: () => InvalidSubnetException,
+  ListenerNotFoundException: () => ListenerNotFoundException,
+  LoadBalancerAttributeNotFoundException: () => LoadBalancerAttributeNotFoundException,
+  ModifyLoadBalancerAttributesCommand: () => ModifyLoadBalancerAttributesCommand,
+  OperationNotPermittedException: () => OperationNotPermittedException,
+  PolicyNotFoundException: () => PolicyNotFoundException,
+  PolicyTypeNotFoundException: () => PolicyTypeNotFoundException,
+  RegisterInstancesWithLoadBalancerCommand: () => RegisterInstancesWithLoadBalancerCommand,
+  RemoveTagsCommand: () => RemoveTagsCommand,
+  SetLoadBalancerListenerSSLCertificateCommand: () => SetLoadBalancerListenerSSLCertificateCommand,
+  SetLoadBalancerPoliciesForBackendServerCommand: () => SetLoadBalancerPoliciesForBackendServerCommand,
+  SetLoadBalancerPoliciesOfListenerCommand: () => SetLoadBalancerPoliciesOfListenerCommand,
+  SubnetNotFoundException: () => SubnetNotFoundException,
+  TooManyAccessPointsException: () => TooManyAccessPointsException,
+  TooManyPoliciesException: () => TooManyPoliciesException,
+  TooManyTagsException: () => TooManyTagsException,
+  UnsupportedProtocolException: () => UnsupportedProtocolException,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeLoadBalancers: () => paginateDescribeLoadBalancers,
+  waitForAnyInstanceInService: () => waitForAnyInstanceInService,
+  waitForInstanceDeregistered: () => waitForInstanceDeregistered,
+  waitForInstanceInService: () => waitForInstanceInService,
+  waitUntilAnyInstanceInService: () => waitUntilAnyInstanceInService,
+  waitUntilInstanceDeregistered: () => waitUntilInstanceDeregistered,
+  waitUntilInstanceInService: () => waitUntilInstanceInService
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/ElasticLoadBalancingClient.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: "elasticloadbalancing"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/ElasticLoadBalancingClient.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/ElasticLoadBalancingClient.ts
+var _ElasticLoadBalancingClient = class _ElasticLoadBalancingClient 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(_ElasticLoadBalancingClient, "ElasticLoadBalancingClient");
+var ElasticLoadBalancingClient = _ElasticLoadBalancingClient;
+
+// src/ElasticLoadBalancing.ts
+
+
+// src/commands/AddTagsCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_query.ts
+
+
+var import_fast_xml_parser = require("fast-xml-parser");
+
+// src/models/ElasticLoadBalancingServiceException.ts
+
+var _ElasticLoadBalancingServiceException = class _ElasticLoadBalancingServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _ElasticLoadBalancingServiceException.prototype);
+  }
+};
+__name(_ElasticLoadBalancingServiceException, "ElasticLoadBalancingServiceException");
+var ElasticLoadBalancingServiceException = _ElasticLoadBalancingServiceException;
+
+// src/models/models_0.ts
+var _AccessPointNotFoundException = class _AccessPointNotFoundException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessPointNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessPointNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessPointNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_AccessPointNotFoundException, "AccessPointNotFoundException");
+var AccessPointNotFoundException = _AccessPointNotFoundException;
+var _DuplicateTagKeysException = class _DuplicateTagKeysException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DuplicateTagKeysException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DuplicateTagKeysException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DuplicateTagKeysException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_DuplicateTagKeysException, "DuplicateTagKeysException");
+var DuplicateTagKeysException = _DuplicateTagKeysException;
+var _TooManyTagsException = class _TooManyTagsException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyTagsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyTagsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_TooManyTagsException, "TooManyTagsException");
+var TooManyTagsException = _TooManyTagsException;
+var _InvalidConfigurationRequestException = class _InvalidConfigurationRequestException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidConfigurationRequestException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidConfigurationRequestException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidConfigurationRequestException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidConfigurationRequestException, "InvalidConfigurationRequestException");
+var InvalidConfigurationRequestException = _InvalidConfigurationRequestException;
+var _InvalidSecurityGroupException = class _InvalidSecurityGroupException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidSecurityGroupException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidSecurityGroupException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidSecurityGroupException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidSecurityGroupException, "InvalidSecurityGroupException");
+var InvalidSecurityGroupException = _InvalidSecurityGroupException;
+var _InvalidSubnetException = class _InvalidSubnetException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidSubnetException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidSubnetException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidSubnetException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidSubnetException, "InvalidSubnetException");
+var InvalidSubnetException = _InvalidSubnetException;
+var _SubnetNotFoundException = class _SubnetNotFoundException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SubnetNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SubnetNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SubnetNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_SubnetNotFoundException, "SubnetNotFoundException");
+var SubnetNotFoundException = _SubnetNotFoundException;
+var _CertificateNotFoundException = class _CertificateNotFoundException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CertificateNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "CertificateNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _CertificateNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_CertificateNotFoundException, "CertificateNotFoundException");
+var CertificateNotFoundException = _CertificateNotFoundException;
+var _DuplicatePolicyNameException = class _DuplicatePolicyNameException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DuplicatePolicyNameException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DuplicatePolicyNameException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DuplicatePolicyNameException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_DuplicatePolicyNameException, "DuplicatePolicyNameException");
+var DuplicatePolicyNameException = _DuplicatePolicyNameException;
+var _TooManyPoliciesException = class _TooManyPoliciesException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyPoliciesException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyPoliciesException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyPoliciesException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_TooManyPoliciesException, "TooManyPoliciesException");
+var TooManyPoliciesException = _TooManyPoliciesException;
+var _DuplicateAccessPointNameException = class _DuplicateAccessPointNameException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DuplicateAccessPointNameException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DuplicateAccessPointNameException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DuplicateAccessPointNameException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_DuplicateAccessPointNameException, "DuplicateAccessPointNameException");
+var DuplicateAccessPointNameException = _DuplicateAccessPointNameException;
+var _InvalidSchemeException = class _InvalidSchemeException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidSchemeException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidSchemeException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidSchemeException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidSchemeException, "InvalidSchemeException");
+var InvalidSchemeException = _InvalidSchemeException;
+var _OperationNotPermittedException = class _OperationNotPermittedException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "OperationNotPermittedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "OperationNotPermittedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _OperationNotPermittedException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_OperationNotPermittedException, "OperationNotPermittedException");
+var OperationNotPermittedException = _OperationNotPermittedException;
+var _TooManyAccessPointsException = class _TooManyAccessPointsException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TooManyAccessPointsException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TooManyAccessPointsException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TooManyAccessPointsException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_TooManyAccessPointsException, "TooManyAccessPointsException");
+var TooManyAccessPointsException = _TooManyAccessPointsException;
+var _UnsupportedProtocolException = class _UnsupportedProtocolException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedProtocolException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedProtocolException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedProtocolException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_UnsupportedProtocolException, "UnsupportedProtocolException");
+var UnsupportedProtocolException = _UnsupportedProtocolException;
+var _DuplicateListenerException = class _DuplicateListenerException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DuplicateListenerException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DuplicateListenerException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DuplicateListenerException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_DuplicateListenerException, "DuplicateListenerException");
+var DuplicateListenerException = _DuplicateListenerException;
+var _PolicyTypeNotFoundException = class _PolicyTypeNotFoundException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PolicyTypeNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PolicyTypeNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PolicyTypeNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_PolicyTypeNotFoundException, "PolicyTypeNotFoundException");
+var PolicyTypeNotFoundException = _PolicyTypeNotFoundException;
+var _DependencyThrottleException = class _DependencyThrottleException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DependencyThrottleException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DependencyThrottleException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DependencyThrottleException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_DependencyThrottleException, "DependencyThrottleException");
+var DependencyThrottleException = _DependencyThrottleException;
+var _InvalidEndPointException = class _InvalidEndPointException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidEndPointException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidEndPointException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidEndPointException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_InvalidEndPointException, "InvalidEndPointException");
+var InvalidEndPointException = _InvalidEndPointException;
+var _LoadBalancerAttributeNotFoundException = class _LoadBalancerAttributeNotFoundException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "LoadBalancerAttributeNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "LoadBalancerAttributeNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _LoadBalancerAttributeNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_LoadBalancerAttributeNotFoundException, "LoadBalancerAttributeNotFoundException");
+var LoadBalancerAttributeNotFoundException = _LoadBalancerAttributeNotFoundException;
+var _PolicyNotFoundException = class _PolicyNotFoundException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "PolicyNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "PolicyNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _PolicyNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_PolicyNotFoundException, "PolicyNotFoundException");
+var PolicyNotFoundException = _PolicyNotFoundException;
+var _ListenerNotFoundException = class _ListenerNotFoundException extends ElasticLoadBalancingServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ListenerNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ListenerNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ListenerNotFoundException.prototype);
+    this.Message = opts.Message;
+  }
+};
+__name(_ListenerNotFoundException, "ListenerNotFoundException");
+var ListenerNotFoundException = _ListenerNotFoundException;
+
+// src/protocols/Aws_query.ts
+var se_AddTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_AddTagsInput(input, context),
+    [_A]: _AT,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AddTagsCommand");
+var se_ApplySecurityGroupsToLoadBalancerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_ApplySecurityGroupsToLoadBalancerInput(input, context),
+    [_A]: _ASGTLB,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ApplySecurityGroupsToLoadBalancerCommand");
+var se_AttachLoadBalancerToSubnetsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_AttachLoadBalancerToSubnetsInput(input, context),
+    [_A]: _ALBTS,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AttachLoadBalancerToSubnetsCommand");
+var se_ConfigureHealthCheckCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_ConfigureHealthCheckInput(input, context),
+    [_A]: _CHC,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ConfigureHealthCheckCommand");
+var se_CreateAppCookieStickinessPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_CreateAppCookieStickinessPolicyInput(input, context),
+    [_A]: _CACSP,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateAppCookieStickinessPolicyCommand");
+var se_CreateLBCookieStickinessPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_CreateLBCookieStickinessPolicyInput(input, context),
+    [_A]: _CLBCSP,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateLBCookieStickinessPolicyCommand");
+var se_CreateLoadBalancerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_CreateAccessPointInput(input, context),
+    [_A]: _CLB,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateLoadBalancerCommand");
+var se_CreateLoadBalancerListenersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_CreateLoadBalancerListenerInput(input, context),
+    [_A]: _CLBL,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateLoadBalancerListenersCommand");
+var se_CreateLoadBalancerPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_CreateLoadBalancerPolicyInput(input, context),
+    [_A]: _CLBP,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateLoadBalancerPolicyCommand");
+var se_DeleteLoadBalancerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DeleteAccessPointInput(input, context),
+    [_A]: _DLB,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteLoadBalancerCommand");
+var se_DeleteLoadBalancerListenersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DeleteLoadBalancerListenerInput(input, context),
+    [_A]: _DLBL,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteLoadBalancerListenersCommand");
+var se_DeleteLoadBalancerPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DeleteLoadBalancerPolicyInput(input, context),
+    [_A]: _DLBP,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteLoadBalancerPolicyCommand");
+var se_DeregisterInstancesFromLoadBalancerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DeregisterEndPointsInput(input, context),
+    [_A]: _DIFLB,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeregisterInstancesFromLoadBalancerCommand");
+var se_DescribeAccountLimitsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeAccountLimitsInput(input, context),
+    [_A]: _DAL,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeAccountLimitsCommand");
+var se_DescribeInstanceHealthCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeEndPointStateInput(input, context),
+    [_A]: _DIH,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeInstanceHealthCommand");
+var se_DescribeLoadBalancerAttributesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeLoadBalancerAttributesInput(input, context),
+    [_A]: _DLBA,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeLoadBalancerAttributesCommand");
+var se_DescribeLoadBalancerPoliciesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeLoadBalancerPoliciesInput(input, context),
+    [_A]: _DLBPe,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeLoadBalancerPoliciesCommand");
+var se_DescribeLoadBalancerPolicyTypesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeLoadBalancerPolicyTypesInput(input, context),
+    [_A]: _DLBPT,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeLoadBalancerPolicyTypesCommand");
+var se_DescribeLoadBalancersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeAccessPointsInput(input, context),
+    [_A]: _DLBe,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeLoadBalancersCommand");
+var se_DescribeTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DescribeTagsInput(input, context),
+    [_A]: _DT,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeTagsCommand");
+var se_DetachLoadBalancerFromSubnetsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_DetachLoadBalancerFromSubnetsInput(input, context),
+    [_A]: _DLBFS,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DetachLoadBalancerFromSubnetsCommand");
+var se_DisableAvailabilityZonesForLoadBalancerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_RemoveAvailabilityZonesInput(input, context),
+    [_A]: _DAZFLB,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisableAvailabilityZonesForLoadBalancerCommand");
+var se_EnableAvailabilityZonesForLoadBalancerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_AddAvailabilityZonesInput(input, context),
+    [_A]: _EAZFLB,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_EnableAvailabilityZonesForLoadBalancerCommand");
+var se_ModifyLoadBalancerAttributesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_ModifyLoadBalancerAttributesInput(input, context),
+    [_A]: _MLBA,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ModifyLoadBalancerAttributesCommand");
+var se_RegisterInstancesWithLoadBalancerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_RegisterEndPointsInput(input, context),
+    [_A]: _RIWLB,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RegisterInstancesWithLoadBalancerCommand");
+var se_RemoveTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_RemoveTagsInput(input, context),
+    [_A]: _RT,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RemoveTagsCommand");
+var se_SetLoadBalancerListenerSSLCertificateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_SetLoadBalancerListenerSSLCertificateInput(input, context),
+    [_A]: _SLBLSSLC,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SetLoadBalancerListenerSSLCertificateCommand");
+var se_SetLoadBalancerPoliciesForBackendServerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_SetLoadBalancerPoliciesForBackendServerInput(input, context),
+    [_A]: _SLBPFBS,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SetLoadBalancerPoliciesForBackendServerCommand");
+var se_SetLoadBalancerPoliciesOfListenerCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = SHARED_HEADERS;
+  let body;
+  body = buildFormUrlencodedString({
+    ...se_SetLoadBalancerPoliciesOfListenerInput(input, context),
+    [_A]: _SLBPOL,
+    [_V]: _
+  });
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_SetLoadBalancerPoliciesOfListenerCommand");
+var de_AddTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AddTagsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_AddTagsOutput(data.AddTagsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AddTagsCommand");
+var de_AddTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicateTagKeys":
+    case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    case "TooManyTags":
+    case "com.amazonaws.elasticloadbalancing#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_AddTagsCommandError");
+var de_ApplySecurityGroupsToLoadBalancerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ApplySecurityGroupsToLoadBalancerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ApplySecurityGroupsToLoadBalancerOutput(data.ApplySecurityGroupsToLoadBalancerResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ApplySecurityGroupsToLoadBalancerCommand");
+var de_ApplySecurityGroupsToLoadBalancerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "InvalidSecurityGroup":
+    case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException":
+      throw await de_InvalidSecurityGroupExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_ApplySecurityGroupsToLoadBalancerCommandError");
+var de_AttachLoadBalancerToSubnetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AttachLoadBalancerToSubnetsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_AttachLoadBalancerToSubnetsOutput(data.AttachLoadBalancerToSubnetsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AttachLoadBalancerToSubnetsCommand");
+var de_AttachLoadBalancerToSubnetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "InvalidSubnet":
+    case "com.amazonaws.elasticloadbalancing#InvalidSubnetException":
+      throw await de_InvalidSubnetExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    case "SubnetNotFound":
+    case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException":
+      throw await de_SubnetNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_AttachLoadBalancerToSubnetsCommandError");
+var de_ConfigureHealthCheckCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ConfigureHealthCheckCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ConfigureHealthCheckOutput(data.ConfigureHealthCheckResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ConfigureHealthCheckCommand");
+var de_ConfigureHealthCheckCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_ConfigureHealthCheckCommandError");
+var de_CreateAppCookieStickinessPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateAppCookieStickinessPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateAppCookieStickinessPolicyOutput(data.CreateAppCookieStickinessPolicyResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateAppCookieStickinessPolicyCommand");
+var de_CreateAppCookieStickinessPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicatePolicyName":
+    case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
+      throw await de_DuplicatePolicyNameExceptionRes(parsedOutput, context);
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    case "TooManyPolicies":
+    case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
+      throw await de_TooManyPoliciesExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_CreateAppCookieStickinessPolicyCommandError");
+var de_CreateLBCookieStickinessPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateLBCookieStickinessPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateLBCookieStickinessPolicyOutput(data.CreateLBCookieStickinessPolicyResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateLBCookieStickinessPolicyCommand");
+var de_CreateLBCookieStickinessPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicatePolicyName":
+    case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
+      throw await de_DuplicatePolicyNameExceptionRes(parsedOutput, context);
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    case "TooManyPolicies":
+    case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
+      throw await de_TooManyPoliciesExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_CreateLBCookieStickinessPolicyCommandError");
+var de_CreateLoadBalancerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateLoadBalancerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateAccessPointOutput(data.CreateLoadBalancerResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateLoadBalancerCommand");
+var de_CreateLoadBalancerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CertificateNotFound":
+    case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
+      throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
+    case "DuplicateLoadBalancerName":
+    case "com.amazonaws.elasticloadbalancing#DuplicateAccessPointNameException":
+      throw await de_DuplicateAccessPointNameExceptionRes(parsedOutput, context);
+    case "DuplicateTagKeys":
+    case "com.amazonaws.elasticloadbalancing#DuplicateTagKeysException":
+      throw await de_DuplicateTagKeysExceptionRes(parsedOutput, context);
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "InvalidScheme":
+    case "com.amazonaws.elasticloadbalancing#InvalidSchemeException":
+      throw await de_InvalidSchemeExceptionRes(parsedOutput, context);
+    case "InvalidSecurityGroup":
+    case "com.amazonaws.elasticloadbalancing#InvalidSecurityGroupException":
+      throw await de_InvalidSecurityGroupExceptionRes(parsedOutput, context);
+    case "InvalidSubnet":
+    case "com.amazonaws.elasticloadbalancing#InvalidSubnetException":
+      throw await de_InvalidSubnetExceptionRes(parsedOutput, context);
+    case "OperationNotPermitted":
+    case "com.amazonaws.elasticloadbalancing#OperationNotPermittedException":
+      throw await de_OperationNotPermittedExceptionRes(parsedOutput, context);
+    case "SubnetNotFound":
+    case "com.amazonaws.elasticloadbalancing#SubnetNotFoundException":
+      throw await de_SubnetNotFoundExceptionRes(parsedOutput, context);
+    case "TooManyLoadBalancers":
+    case "com.amazonaws.elasticloadbalancing#TooManyAccessPointsException":
+      throw await de_TooManyAccessPointsExceptionRes(parsedOutput, context);
+    case "TooManyTags":
+    case "com.amazonaws.elasticloadbalancing#TooManyTagsException":
+      throw await de_TooManyTagsExceptionRes(parsedOutput, context);
+    case "UnsupportedProtocol":
+    case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException":
+      throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_CreateLoadBalancerCommandError");
+var de_CreateLoadBalancerListenersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateLoadBalancerListenersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateLoadBalancerListenerOutput(data.CreateLoadBalancerListenersResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateLoadBalancerListenersCommand");
+var de_CreateLoadBalancerListenersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CertificateNotFound":
+    case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
+      throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
+    case "DuplicateListener":
+    case "com.amazonaws.elasticloadbalancing#DuplicateListenerException":
+      throw await de_DuplicateListenerExceptionRes(parsedOutput, context);
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedProtocol":
+    case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException":
+      throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_CreateLoadBalancerListenersCommandError");
+var de_CreateLoadBalancerPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateLoadBalancerPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateLoadBalancerPolicyOutput(data.CreateLoadBalancerPolicyResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateLoadBalancerPolicyCommand");
+var de_CreateLoadBalancerPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DuplicatePolicyName":
+    case "com.amazonaws.elasticloadbalancing#DuplicatePolicyNameException":
+      throw await de_DuplicatePolicyNameExceptionRes(parsedOutput, context);
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    case "PolicyTypeNotFound":
+    case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException":
+      throw await de_PolicyTypeNotFoundExceptionRes(parsedOutput, context);
+    case "TooManyPolicies":
+    case "com.amazonaws.elasticloadbalancing#TooManyPoliciesException":
+      throw await de_TooManyPoliciesExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_CreateLoadBalancerPolicyCommandError");
+var de_DeleteLoadBalancerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteLoadBalancerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteAccessPointOutput(data.DeleteLoadBalancerResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteLoadBalancerCommand");
+var de_DeleteLoadBalancerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  const parsedBody = parsedOutput.body;
+  return throwDefaultError({
+    output,
+    parsedBody: parsedBody.Error,
+    errorCode
+  });
+}, "de_DeleteLoadBalancerCommandError");
+var de_DeleteLoadBalancerListenersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteLoadBalancerListenersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteLoadBalancerListenerOutput(data.DeleteLoadBalancerListenersResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteLoadBalancerListenersCommand");
+var de_DeleteLoadBalancerListenersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DeleteLoadBalancerListenersCommandError");
+var de_DeleteLoadBalancerPolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteLoadBalancerPolicyCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteLoadBalancerPolicyOutput(data.DeleteLoadBalancerPolicyResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteLoadBalancerPolicyCommand");
+var de_DeleteLoadBalancerPolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DeleteLoadBalancerPolicyCommandError");
+var de_DeregisterInstancesFromLoadBalancerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeregisterInstancesFromLoadBalancerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeregisterEndPointsOutput(data.DeregisterInstancesFromLoadBalancerResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeregisterInstancesFromLoadBalancerCommand");
+var de_DeregisterInstancesFromLoadBalancerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInstance":
+    case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
+      throw await de_InvalidEndPointExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DeregisterInstancesFromLoadBalancerCommandError");
+var de_DescribeAccountLimitsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeAccountLimitsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeAccountLimitsOutput(data.DescribeAccountLimitsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeAccountLimitsCommand");
+var de_DescribeAccountLimitsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  const parsedBody = parsedOutput.body;
+  return throwDefaultError({
+    output,
+    parsedBody: parsedBody.Error,
+    errorCode
+  });
+}, "de_DescribeAccountLimitsCommandError");
+var de_DescribeInstanceHealthCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeInstanceHealthCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeEndPointStateOutput(data.DescribeInstanceHealthResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeInstanceHealthCommand");
+var de_DescribeInstanceHealthCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInstance":
+    case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
+      throw await de_InvalidEndPointExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeInstanceHealthCommandError");
+var de_DescribeLoadBalancerAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeLoadBalancerAttributesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeLoadBalancerAttributesOutput(data.DescribeLoadBalancerAttributesResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeLoadBalancerAttributesCommand");
+var de_DescribeLoadBalancerAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LoadBalancerAttributeNotFound":
+    case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException":
+      throw await de_LoadBalancerAttributeNotFoundExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeLoadBalancerAttributesCommandError");
+var de_DescribeLoadBalancerPoliciesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeLoadBalancerPoliciesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeLoadBalancerPoliciesOutput(data.DescribeLoadBalancerPoliciesResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeLoadBalancerPoliciesCommand");
+var de_DescribeLoadBalancerPoliciesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    case "PolicyNotFound":
+    case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
+      throw await de_PolicyNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeLoadBalancerPoliciesCommandError");
+var de_DescribeLoadBalancerPolicyTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeLoadBalancerPolicyTypesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeLoadBalancerPolicyTypesOutput(data.DescribeLoadBalancerPolicyTypesResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeLoadBalancerPolicyTypesCommand");
+var de_DescribeLoadBalancerPolicyTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "PolicyTypeNotFound":
+    case "com.amazonaws.elasticloadbalancing#PolicyTypeNotFoundException":
+      throw await de_PolicyTypeNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeLoadBalancerPolicyTypesCommandError");
+var de_DescribeLoadBalancersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeLoadBalancersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeAccessPointsOutput(data.DescribeLoadBalancersResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeLoadBalancersCommand");
+var de_DescribeLoadBalancersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "DependencyThrottle":
+    case "com.amazonaws.elasticloadbalancing#DependencyThrottleException":
+      throw await de_DependencyThrottleExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeLoadBalancersCommandError");
+var de_DescribeTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeTagsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeTagsOutput(data.DescribeTagsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeTagsCommand");
+var de_DescribeTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DescribeTagsCommandError");
+var de_DetachLoadBalancerFromSubnetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DetachLoadBalancerFromSubnetsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DetachLoadBalancerFromSubnetsOutput(data.DetachLoadBalancerFromSubnetsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DetachLoadBalancerFromSubnetsCommand");
+var de_DetachLoadBalancerFromSubnetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DetachLoadBalancerFromSubnetsCommandError");
+var de_DisableAvailabilityZonesForLoadBalancerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisableAvailabilityZonesForLoadBalancerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_RemoveAvailabilityZonesOutput(data.DisableAvailabilityZonesForLoadBalancerResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DisableAvailabilityZonesForLoadBalancerCommand");
+var de_DisableAvailabilityZonesForLoadBalancerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_DisableAvailabilityZonesForLoadBalancerCommandError");
+var de_EnableAvailabilityZonesForLoadBalancerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_EnableAvailabilityZonesForLoadBalancerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_AddAvailabilityZonesOutput(data.EnableAvailabilityZonesForLoadBalancerResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_EnableAvailabilityZonesForLoadBalancerCommand");
+var de_EnableAvailabilityZonesForLoadBalancerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_EnableAvailabilityZonesForLoadBalancerCommandError");
+var de_ModifyLoadBalancerAttributesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ModifyLoadBalancerAttributesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_ModifyLoadBalancerAttributesOutput(data.ModifyLoadBalancerAttributesResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ModifyLoadBalancerAttributesCommand");
+var de_ModifyLoadBalancerAttributesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "LoadBalancerAttributeNotFound":
+    case "com.amazonaws.elasticloadbalancing#LoadBalancerAttributeNotFoundException":
+      throw await de_LoadBalancerAttributeNotFoundExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_ModifyLoadBalancerAttributesCommandError");
+var de_RegisterInstancesWithLoadBalancerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RegisterInstancesWithLoadBalancerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_RegisterEndPointsOutput(data.RegisterInstancesWithLoadBalancerResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RegisterInstancesWithLoadBalancerCommand");
+var de_RegisterInstancesWithLoadBalancerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidInstance":
+    case "com.amazonaws.elasticloadbalancing#InvalidEndPointException":
+      throw await de_InvalidEndPointExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_RegisterInstancesWithLoadBalancerCommandError");
+var de_RemoveTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RemoveTagsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_RemoveTagsOutput(data.RemoveTagsResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RemoveTagsCommand");
+var de_RemoveTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_RemoveTagsCommandError");
+var de_SetLoadBalancerListenerSSLCertificateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SetLoadBalancerListenerSSLCertificateCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_SetLoadBalancerListenerSSLCertificateOutput(data.SetLoadBalancerListenerSSLCertificateResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SetLoadBalancerListenerSSLCertificateCommand");
+var de_SetLoadBalancerListenerSSLCertificateCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CertificateNotFound":
+    case "com.amazonaws.elasticloadbalancing#CertificateNotFoundException":
+      throw await de_CertificateNotFoundExceptionRes(parsedOutput, context);
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "ListenerNotFound":
+    case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException":
+      throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    case "UnsupportedProtocol":
+    case "com.amazonaws.elasticloadbalancing#UnsupportedProtocolException":
+      throw await de_UnsupportedProtocolExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_SetLoadBalancerListenerSSLCertificateCommandError");
+var de_SetLoadBalancerPoliciesForBackendServerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SetLoadBalancerPoliciesForBackendServerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_SetLoadBalancerPoliciesForBackendServerOutput(
+    data.SetLoadBalancerPoliciesForBackendServerResult,
+    context
+  );
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SetLoadBalancerPoliciesForBackendServerCommand");
+var de_SetLoadBalancerPoliciesForBackendServerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    case "PolicyNotFound":
+    case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
+      throw await de_PolicyNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_SetLoadBalancerPoliciesForBackendServerCommandError");
+var de_SetLoadBalancerPoliciesOfListenerCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_SetLoadBalancerPoliciesOfListenerCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_SetLoadBalancerPoliciesOfListenerOutput(data.SetLoadBalancerPoliciesOfListenerResult, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_SetLoadBalancerPoliciesOfListenerCommand");
+var de_SetLoadBalancerPoliciesOfListenerCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidConfigurationRequest":
+    case "com.amazonaws.elasticloadbalancing#InvalidConfigurationRequestException":
+      throw await de_InvalidConfigurationRequestExceptionRes(parsedOutput, context);
+    case "ListenerNotFound":
+    case "com.amazonaws.elasticloadbalancing#ListenerNotFoundException":
+      throw await de_ListenerNotFoundExceptionRes(parsedOutput, context);
+    case "LoadBalancerNotFound":
+    case "com.amazonaws.elasticloadbalancing#AccessPointNotFoundException":
+      throw await de_AccessPointNotFoundExceptionRes(parsedOutput, context);
+    case "PolicyNotFound":
+    case "com.amazonaws.elasticloadbalancing#PolicyNotFoundException":
+      throw await de_PolicyNotFoundExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody: parsedBody.Error,
+        errorCode
+      });
+  }
+}, "de_SetLoadBalancerPoliciesOfListenerCommandError");
+var de_AccessPointNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_AccessPointNotFoundException(body.Error, context);
+  const exception = new AccessPointNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AccessPointNotFoundExceptionRes");
+var de_CertificateNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_CertificateNotFoundException(body.Error, context);
+  const exception = new CertificateNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CertificateNotFoundExceptionRes");
+var de_DependencyThrottleExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_DependencyThrottleException(body.Error, context);
+  const exception = new DependencyThrottleException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DependencyThrottleExceptionRes");
+var de_DuplicateAccessPointNameExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_DuplicateAccessPointNameException(body.Error, context);
+  const exception = new DuplicateAccessPointNameException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DuplicateAccessPointNameExceptionRes");
+var de_DuplicateListenerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_DuplicateListenerException(body.Error, context);
+  const exception = new DuplicateListenerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DuplicateListenerExceptionRes");
+var de_DuplicatePolicyNameExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_DuplicatePolicyNameException(body.Error, context);
+  const exception = new DuplicatePolicyNameException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DuplicatePolicyNameExceptionRes");
+var de_DuplicateTagKeysExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_DuplicateTagKeysException(body.Error, context);
+  const exception = new DuplicateTagKeysException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DuplicateTagKeysExceptionRes");
+var de_InvalidConfigurationRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_InvalidConfigurationRequestException(body.Error, context);
+  const exception = new InvalidConfigurationRequestException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidConfigurationRequestExceptionRes");
+var de_InvalidEndPointExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_InvalidEndPointException(body.Error, context);
+  const exception = new InvalidEndPointException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidEndPointExceptionRes");
+var de_InvalidSchemeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_InvalidSchemeException(body.Error, context);
+  const exception = new InvalidSchemeException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidSchemeExceptionRes");
+var de_InvalidSecurityGroupExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_InvalidSecurityGroupException(body.Error, context);
+  const exception = new InvalidSecurityGroupException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidSecurityGroupExceptionRes");
+var de_InvalidSubnetExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_InvalidSubnetException(body.Error, context);
+  const exception = new InvalidSubnetException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidSubnetExceptionRes");
+var de_ListenerNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_ListenerNotFoundException(body.Error, context);
+  const exception = new ListenerNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ListenerNotFoundExceptionRes");
+var de_LoadBalancerAttributeNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_LoadBalancerAttributeNotFoundException(body.Error, context);
+  const exception = new LoadBalancerAttributeNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_LoadBalancerAttributeNotFoundExceptionRes");
+var de_OperationNotPermittedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_OperationNotPermittedException(body.Error, context);
+  const exception = new OperationNotPermittedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_OperationNotPermittedExceptionRes");
+var de_PolicyNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_PolicyNotFoundException(body.Error, context);
+  const exception = new PolicyNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_PolicyNotFoundExceptionRes");
+var de_PolicyTypeNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_PolicyTypeNotFoundException(body.Error, context);
+  const exception = new PolicyTypeNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_PolicyTypeNotFoundExceptionRes");
+var de_SubnetNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_SubnetNotFoundException(body.Error, context);
+  const exception = new SubnetNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_SubnetNotFoundExceptionRes");
+var de_TooManyAccessPointsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_TooManyAccessPointsException(body.Error, context);
+  const exception = new TooManyAccessPointsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TooManyAccessPointsExceptionRes");
+var de_TooManyPoliciesExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_TooManyPoliciesException(body.Error, context);
+  const exception = new TooManyPoliciesException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TooManyPoliciesExceptionRes");
+var de_TooManyTagsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_TooManyTagsException(body.Error, context);
+  const exception = new TooManyTagsException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TooManyTagsExceptionRes");
+var de_UnsupportedProtocolExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = de_UnsupportedProtocolException(body.Error, context);
+  const exception = new UnsupportedProtocolException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnsupportedProtocolExceptionRes");
+var se_AccessLog = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_E] != null) {
+    entries[_E] = input[_E];
+  }
+  if (input[_SBN] != null) {
+    entries[_SBN] = input[_SBN];
+  }
+  if (input[_EI] != null) {
+    entries[_EI] = input[_EI];
+  }
+  if (input[_SBP] != null) {
+    entries[_SBP] = input[_SBP];
+  }
+  return entries;
+}, "se_AccessLog");
+var se_AddAvailabilityZonesInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_AZ] != null) {
+    const memberEntries = se_AvailabilityZones(input[_AZ], context);
+    if (((_a = input[_AZ]) == null ? void 0 : _a.length) === 0) {
+      entries.AvailabilityZones = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `AvailabilityZones.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_AddAvailabilityZonesInput");
+var se_AdditionalAttribute = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_K] != null) {
+    entries[_K] = input[_K];
+  }
+  if (input[_Va] != null) {
+    entries[_Va] = input[_Va];
+  }
+  return entries;
+}, "se_AdditionalAttribute");
+var se_AdditionalAttributes = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    const memberEntries = se_AdditionalAttribute(entry, context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      entries[`member.${counter}.${key}`] = value;
+    });
+    counter++;
+  }
+  return entries;
+}, "se_AdditionalAttributes");
+var se_AddTagsInput = /* @__PURE__ */ __name((input, context) => {
+  var _a, _b;
+  const entries = {};
+  if (input[_LBNo] != null) {
+    const memberEntries = se_LoadBalancerNames(input[_LBNo], context);
+    if (((_a = input[_LBNo]) == null ? void 0 : _a.length) === 0) {
+      entries.LoadBalancerNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `LoadBalancerNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_T] != null) {
+    const memberEntries = se_TagList(input[_T], context);
+    if (((_b = input[_T]) == null ? void 0 : _b.length) === 0) {
+      entries.Tags = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Tags.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_AddTagsInput");
+var se_ApplySecurityGroupsToLoadBalancerInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_SG] != null) {
+    const memberEntries = se_SecurityGroups(input[_SG], context);
+    if (((_a = input[_SG]) == null ? void 0 : _a.length) === 0) {
+      entries.SecurityGroups = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `SecurityGroups.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_ApplySecurityGroupsToLoadBalancerInput");
+var se_AttachLoadBalancerToSubnetsInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_S] != null) {
+    const memberEntries = se_Subnets(input[_S], context);
+    if (((_a = input[_S]) == null ? void 0 : _a.length) === 0) {
+      entries.Subnets = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Subnets.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_AttachLoadBalancerToSubnetsInput");
+var se_AvailabilityZones = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    entries[`member.${counter}`] = entry;
+    counter++;
+  }
+  return entries;
+}, "se_AvailabilityZones");
+var se_ConfigureHealthCheckInput = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_HC] != null) {
+    const memberEntries = se_HealthCheck(input[_HC], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `HealthCheck.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_ConfigureHealthCheckInput");
+var se_ConnectionDraining = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_E] != null) {
+    entries[_E] = input[_E];
+  }
+  if (input[_Ti] != null) {
+    entries[_Ti] = input[_Ti];
+  }
+  return entries;
+}, "se_ConnectionDraining");
+var se_ConnectionSettings = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_IT] != null) {
+    entries[_IT] = input[_IT];
+  }
+  return entries;
+}, "se_ConnectionSettings");
+var se_CreateAccessPointInput = /* @__PURE__ */ __name((input, context) => {
+  var _a, _b, _c, _d, _e;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_L] != null) {
+    const memberEntries = se_Listeners(input[_L], context);
+    if (((_a = input[_L]) == null ? void 0 : _a.length) === 0) {
+      entries.Listeners = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Listeners.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_AZ] != null) {
+    const memberEntries = se_AvailabilityZones(input[_AZ], context);
+    if (((_b = input[_AZ]) == null ? void 0 : _b.length) === 0) {
+      entries.AvailabilityZones = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `AvailabilityZones.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_S] != null) {
+    const memberEntries = se_Subnets(input[_S], context);
+    if (((_c = input[_S]) == null ? void 0 : _c.length) === 0) {
+      entries.Subnets = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Subnets.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_SG] != null) {
+    const memberEntries = se_SecurityGroups(input[_SG], context);
+    if (((_d = input[_SG]) == null ? void 0 : _d.length) === 0) {
+      entries.SecurityGroups = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `SecurityGroups.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_Sc] != null) {
+    entries[_Sc] = input[_Sc];
+  }
+  if (input[_T] != null) {
+    const memberEntries = se_TagList(input[_T], context);
+    if (((_e = input[_T]) == null ? void 0 : _e.length) === 0) {
+      entries.Tags = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Tags.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_CreateAccessPointInput");
+var se_CreateAppCookieStickinessPolicyInput = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_PN] != null) {
+    entries[_PN] = input[_PN];
+  }
+  if (input[_CN] != null) {
+    entries[_CN] = input[_CN];
+  }
+  return entries;
+}, "se_CreateAppCookieStickinessPolicyInput");
+var se_CreateLBCookieStickinessPolicyInput = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_PN] != null) {
+    entries[_PN] = input[_PN];
+  }
+  if (input[_CEP] != null) {
+    entries[_CEP] = input[_CEP];
+  }
+  return entries;
+}, "se_CreateLBCookieStickinessPolicyInput");
+var se_CreateLoadBalancerListenerInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_L] != null) {
+    const memberEntries = se_Listeners(input[_L], context);
+    if (((_a = input[_L]) == null ? void 0 : _a.length) === 0) {
+      entries.Listeners = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Listeners.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_CreateLoadBalancerListenerInput");
+var se_CreateLoadBalancerPolicyInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_PN] != null) {
+    entries[_PN] = input[_PN];
+  }
+  if (input[_PTN] != null) {
+    entries[_PTN] = input[_PTN];
+  }
+  if (input[_PA] != null) {
+    const memberEntries = se_PolicyAttributes(input[_PA], context);
+    if (((_a = input[_PA]) == null ? void 0 : _a.length) === 0) {
+      entries.PolicyAttributes = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `PolicyAttributes.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_CreateLoadBalancerPolicyInput");
+var se_CrossZoneLoadBalancing = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_E] != null) {
+    entries[_E] = input[_E];
+  }
+  return entries;
+}, "se_CrossZoneLoadBalancing");
+var se_DeleteAccessPointInput = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  return entries;
+}, "se_DeleteAccessPointInput");
+var se_DeleteLoadBalancerListenerInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_LBP] != null) {
+    const memberEntries = se_Ports(input[_LBP], context);
+    if (((_a = input[_LBP]) == null ? void 0 : _a.length) === 0) {
+      entries.LoadBalancerPorts = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `LoadBalancerPorts.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DeleteLoadBalancerListenerInput");
+var se_DeleteLoadBalancerPolicyInput = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_PN] != null) {
+    entries[_PN] = input[_PN];
+  }
+  return entries;
+}, "se_DeleteLoadBalancerPolicyInput");
+var se_DeregisterEndPointsInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_I] != null) {
+    const memberEntries = se_Instances(input[_I], context);
+    if (((_a = input[_I]) == null ? void 0 : _a.length) === 0) {
+      entries.Instances = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Instances.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DeregisterEndPointsInput");
+var se_DescribeAccessPointsInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBNo] != null) {
+    const memberEntries = se_LoadBalancerNames(input[_LBNo], context);
+    if (((_a = input[_LBNo]) == null ? void 0 : _a.length) === 0) {
+      entries.LoadBalancerNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `LoadBalancerNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_M] != null) {
+    entries[_M] = input[_M];
+  }
+  if (input[_PS] != null) {
+    entries[_PS] = input[_PS];
+  }
+  return entries;
+}, "se_DescribeAccessPointsInput");
+var se_DescribeAccountLimitsInput = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_M] != null) {
+    entries[_M] = input[_M];
+  }
+  if (input[_PS] != null) {
+    entries[_PS] = input[_PS];
+  }
+  return entries;
+}, "se_DescribeAccountLimitsInput");
+var se_DescribeEndPointStateInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_I] != null) {
+    const memberEntries = se_Instances(input[_I], context);
+    if (((_a = input[_I]) == null ? void 0 : _a.length) === 0) {
+      entries.Instances = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Instances.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DescribeEndPointStateInput");
+var se_DescribeLoadBalancerAttributesInput = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  return entries;
+}, "se_DescribeLoadBalancerAttributesInput");
+var se_DescribeLoadBalancerPoliciesInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_PNo] != null) {
+    const memberEntries = se_PolicyNames(input[_PNo], context);
+    if (((_a = input[_PNo]) == null ? void 0 : _a.length) === 0) {
+      entries.PolicyNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `PolicyNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DescribeLoadBalancerPoliciesInput");
+var se_DescribeLoadBalancerPolicyTypesInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_PTNo] != null) {
+    const memberEntries = se_PolicyTypeNames(input[_PTNo], context);
+    if (((_a = input[_PTNo]) == null ? void 0 : _a.length) === 0) {
+      entries.PolicyTypeNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `PolicyTypeNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DescribeLoadBalancerPolicyTypesInput");
+var se_DescribeTagsInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBNo] != null) {
+    const memberEntries = se_LoadBalancerNamesMax20(input[_LBNo], context);
+    if (((_a = input[_LBNo]) == null ? void 0 : _a.length) === 0) {
+      entries.LoadBalancerNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `LoadBalancerNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DescribeTagsInput");
+var se_DetachLoadBalancerFromSubnetsInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_S] != null) {
+    const memberEntries = se_Subnets(input[_S], context);
+    if (((_a = input[_S]) == null ? void 0 : _a.length) === 0) {
+      entries.Subnets = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Subnets.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_DetachLoadBalancerFromSubnetsInput");
+var se_HealthCheck = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_Ta] != null) {
+    entries[_Ta] = input[_Ta];
+  }
+  if (input[_In] != null) {
+    entries[_In] = input[_In];
+  }
+  if (input[_Ti] != null) {
+    entries[_Ti] = input[_Ti];
+  }
+  if (input[_UT] != null) {
+    entries[_UT] = input[_UT];
+  }
+  if (input[_HT] != null) {
+    entries[_HT] = input[_HT];
+  }
+  return entries;
+}, "se_HealthCheck");
+var se_Instance = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_II] != null) {
+    entries[_II] = input[_II];
+  }
+  return entries;
+}, "se_Instance");
+var se_Instances = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    const memberEntries = se_Instance(entry, context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      entries[`member.${counter}.${key}`] = value;
+    });
+    counter++;
+  }
+  return entries;
+}, "se_Instances");
+var se_Listener = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_P] != null) {
+    entries[_P] = input[_P];
+  }
+  if (input[_LBPo] != null) {
+    entries[_LBPo] = input[_LBPo];
+  }
+  if (input[_IP] != null) {
+    entries[_IP] = input[_IP];
+  }
+  if (input[_IPn] != null) {
+    entries[_IPn] = input[_IPn];
+  }
+  if (input[_SSLCI] != null) {
+    entries[_SSLCI] = input[_SSLCI];
+  }
+  return entries;
+}, "se_Listener");
+var se_Listeners = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    const memberEntries = se_Listener(entry, context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      entries[`member.${counter}.${key}`] = value;
+    });
+    counter++;
+  }
+  return entries;
+}, "se_Listeners");
+var se_LoadBalancerAttributes = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_CZLB] != null) {
+    const memberEntries = se_CrossZoneLoadBalancing(input[_CZLB], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `CrossZoneLoadBalancing.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_AL] != null) {
+    const memberEntries = se_AccessLog(input[_AL], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `AccessLog.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_CD] != null) {
+    const memberEntries = se_ConnectionDraining(input[_CD], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `ConnectionDraining.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_CS] != null) {
+    const memberEntries = se_ConnectionSettings(input[_CS], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `ConnectionSettings.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_AA] != null) {
+    const memberEntries = se_AdditionalAttributes(input[_AA], context);
+    if (((_a = input[_AA]) == null ? void 0 : _a.length) === 0) {
+      entries.AdditionalAttributes = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `AdditionalAttributes.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_LoadBalancerAttributes");
+var se_LoadBalancerNames = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    entries[`member.${counter}`] = entry;
+    counter++;
+  }
+  return entries;
+}, "se_LoadBalancerNames");
+var se_LoadBalancerNamesMax20 = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    entries[`member.${counter}`] = entry;
+    counter++;
+  }
+  return entries;
+}, "se_LoadBalancerNamesMax20");
+var se_ModifyLoadBalancerAttributesInput = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_LBA] != null) {
+    const memberEntries = se_LoadBalancerAttributes(input[_LBA], context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `LoadBalancerAttributes.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_ModifyLoadBalancerAttributesInput");
+var se_PolicyAttribute = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_AN] != null) {
+    entries[_AN] = input[_AN];
+  }
+  if (input[_AV] != null) {
+    entries[_AV] = input[_AV];
+  }
+  return entries;
+}, "se_PolicyAttribute");
+var se_PolicyAttributes = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    const memberEntries = se_PolicyAttribute(entry, context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      entries[`member.${counter}.${key}`] = value;
+    });
+    counter++;
+  }
+  return entries;
+}, "se_PolicyAttributes");
+var se_PolicyNames = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    entries[`member.${counter}`] = entry;
+    counter++;
+  }
+  return entries;
+}, "se_PolicyNames");
+var se_PolicyTypeNames = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    entries[`member.${counter}`] = entry;
+    counter++;
+  }
+  return entries;
+}, "se_PolicyTypeNames");
+var se_Ports = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    entries[`member.${counter}`] = entry;
+    counter++;
+  }
+  return entries;
+}, "se_Ports");
+var se_RegisterEndPointsInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_I] != null) {
+    const memberEntries = se_Instances(input[_I], context);
+    if (((_a = input[_I]) == null ? void 0 : _a.length) === 0) {
+      entries.Instances = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Instances.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_RegisterEndPointsInput");
+var se_RemoveAvailabilityZonesInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_AZ] != null) {
+    const memberEntries = se_AvailabilityZones(input[_AZ], context);
+    if (((_a = input[_AZ]) == null ? void 0 : _a.length) === 0) {
+      entries.AvailabilityZones = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `AvailabilityZones.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_RemoveAvailabilityZonesInput");
+var se_RemoveTagsInput = /* @__PURE__ */ __name((input, context) => {
+  var _a, _b;
+  const entries = {};
+  if (input[_LBNo] != null) {
+    const memberEntries = se_LoadBalancerNames(input[_LBNo], context);
+    if (((_a = input[_LBNo]) == null ? void 0 : _a.length) === 0) {
+      entries.LoadBalancerNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `LoadBalancerNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  if (input[_T] != null) {
+    const memberEntries = se_TagKeyList(input[_T], context);
+    if (((_b = input[_T]) == null ? void 0 : _b.length) === 0) {
+      entries.Tags = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `Tags.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_RemoveTagsInput");
+var se_SecurityGroups = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    entries[`member.${counter}`] = entry;
+    counter++;
+  }
+  return entries;
+}, "se_SecurityGroups");
+var se_SetLoadBalancerListenerSSLCertificateInput = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_LBPo] != null) {
+    entries[_LBPo] = input[_LBPo];
+  }
+  if (input[_SSLCI] != null) {
+    entries[_SSLCI] = input[_SSLCI];
+  }
+  return entries;
+}, "se_SetLoadBalancerListenerSSLCertificateInput");
+var se_SetLoadBalancerPoliciesForBackendServerInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_IPn] != null) {
+    entries[_IPn] = input[_IPn];
+  }
+  if (input[_PNo] != null) {
+    const memberEntries = se_PolicyNames(input[_PNo], context);
+    if (((_a = input[_PNo]) == null ? void 0 : _a.length) === 0) {
+      entries.PolicyNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `PolicyNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_SetLoadBalancerPoliciesForBackendServerInput");
+var se_SetLoadBalancerPoliciesOfListenerInput = /* @__PURE__ */ __name((input, context) => {
+  var _a;
+  const entries = {};
+  if (input[_LBN] != null) {
+    entries[_LBN] = input[_LBN];
+  }
+  if (input[_LBPo] != null) {
+    entries[_LBPo] = input[_LBPo];
+  }
+  if (input[_PNo] != null) {
+    const memberEntries = se_PolicyNames(input[_PNo], context);
+    if (((_a = input[_PNo]) == null ? void 0 : _a.length) === 0) {
+      entries.PolicyNames = [];
+    }
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      const loc = `PolicyNames.${key}`;
+      entries[loc] = value;
+    });
+  }
+  return entries;
+}, "se_SetLoadBalancerPoliciesOfListenerInput");
+var se_Subnets = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    entries[`member.${counter}`] = entry;
+    counter++;
+  }
+  return entries;
+}, "se_Subnets");
+var se_Tag = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_K] != null) {
+    entries[_K] = input[_K];
+  }
+  if (input[_Va] != null) {
+    entries[_Va] = input[_Va];
+  }
+  return entries;
+}, "se_Tag");
+var se_TagKeyList = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    const memberEntries = se_TagKeyOnly(entry, context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      entries[`member.${counter}.${key}`] = value;
+    });
+    counter++;
+  }
+  return entries;
+}, "se_TagKeyList");
+var se_TagKeyOnly = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  if (input[_K] != null) {
+    entries[_K] = input[_K];
+  }
+  return entries;
+}, "se_TagKeyOnly");
+var se_TagList = /* @__PURE__ */ __name((input, context) => {
+  const entries = {};
+  let counter = 1;
+  for (const entry of input) {
+    if (entry === null) {
+      continue;
+    }
+    const memberEntries = se_Tag(entry, context);
+    Object.entries(memberEntries).forEach(([key, value]) => {
+      entries[`member.${counter}.${key}`] = value;
+    });
+    counter++;
+  }
+  return entries;
+}, "se_TagList");
+var de_AccessLog = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_E] != null) {
+    contents[_E] = (0, import_smithy_client.parseBoolean)(output[_E]);
+  }
+  if (output[_SBN] != null) {
+    contents[_SBN] = (0, import_smithy_client.expectString)(output[_SBN]);
+  }
+  if (output[_EI] != null) {
+    contents[_EI] = (0, import_smithy_client.strictParseInt32)(output[_EI]);
+  }
+  if (output[_SBP] != null) {
+    contents[_SBP] = (0, import_smithy_client.expectString)(output[_SBP]);
+  }
+  return contents;
+}, "de_AccessLog");
+var de_AccessPointNotFoundException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_AccessPointNotFoundException");
+var de_AddAvailabilityZonesOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.AvailabilityZones === "") {
+    contents[_AZ] = [];
+  } else if (output[_AZ] != null && output[_AZ][_m] != null) {
+    contents[_AZ] = de_AvailabilityZones((0, import_smithy_client.getArrayIfSingleItem)(output[_AZ][_m]), context);
+  }
+  return contents;
+}, "de_AddAvailabilityZonesOutput");
+var de_AdditionalAttribute = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_K] != null) {
+    contents[_K] = (0, import_smithy_client.expectString)(output[_K]);
+  }
+  if (output[_Va] != null) {
+    contents[_Va] = (0, import_smithy_client.expectString)(output[_Va]);
+  }
+  return contents;
+}, "de_AdditionalAttribute");
+var de_AdditionalAttributes = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_AdditionalAttribute(entry, context);
+  });
+}, "de_AdditionalAttributes");
+var de_AddTagsOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_AddTagsOutput");
+var de_AppCookieStickinessPolicies = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_AppCookieStickinessPolicy(entry, context);
+  });
+}, "de_AppCookieStickinessPolicies");
+var de_AppCookieStickinessPolicy = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_PN] != null) {
+    contents[_PN] = (0, import_smithy_client.expectString)(output[_PN]);
+  }
+  if (output[_CN] != null) {
+    contents[_CN] = (0, import_smithy_client.expectString)(output[_CN]);
+  }
+  return contents;
+}, "de_AppCookieStickinessPolicy");
+var de_ApplySecurityGroupsToLoadBalancerOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.SecurityGroups === "") {
+    contents[_SG] = [];
+  } else if (output[_SG] != null && output[_SG][_m] != null) {
+    contents[_SG] = de_SecurityGroups((0, import_smithy_client.getArrayIfSingleItem)(output[_SG][_m]), context);
+  }
+  return contents;
+}, "de_ApplySecurityGroupsToLoadBalancerOutput");
+var de_AttachLoadBalancerToSubnetsOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.Subnets === "") {
+    contents[_S] = [];
+  } else if (output[_S] != null && output[_S][_m] != null) {
+    contents[_S] = de_Subnets((0, import_smithy_client.getArrayIfSingleItem)(output[_S][_m]), context);
+  }
+  return contents;
+}, "de_AttachLoadBalancerToSubnetsOutput");
+var de_AvailabilityZones = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.expectString)(entry);
+  });
+}, "de_AvailabilityZones");
+var de_BackendServerDescription = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_IPn] != null) {
+    contents[_IPn] = (0, import_smithy_client.strictParseInt32)(output[_IPn]);
+  }
+  if (output.PolicyNames === "") {
+    contents[_PNo] = [];
+  } else if (output[_PNo] != null && output[_PNo][_m] != null) {
+    contents[_PNo] = de_PolicyNames((0, import_smithy_client.getArrayIfSingleItem)(output[_PNo][_m]), context);
+  }
+  return contents;
+}, "de_BackendServerDescription");
+var de_BackendServerDescriptions = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_BackendServerDescription(entry, context);
+  });
+}, "de_BackendServerDescriptions");
+var de_CertificateNotFoundException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_CertificateNotFoundException");
+var de_ConfigureHealthCheckOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_HC] != null) {
+    contents[_HC] = de_HealthCheck(output[_HC], context);
+  }
+  return contents;
+}, "de_ConfigureHealthCheckOutput");
+var de_ConnectionDraining = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_E] != null) {
+    contents[_E] = (0, import_smithy_client.parseBoolean)(output[_E]);
+  }
+  if (output[_Ti] != null) {
+    contents[_Ti] = (0, import_smithy_client.strictParseInt32)(output[_Ti]);
+  }
+  return contents;
+}, "de_ConnectionDraining");
+var de_ConnectionSettings = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_IT] != null) {
+    contents[_IT] = (0, import_smithy_client.strictParseInt32)(output[_IT]);
+  }
+  return contents;
+}, "de_ConnectionSettings");
+var de_CreateAccessPointOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_DNSN] != null) {
+    contents[_DNSN] = (0, import_smithy_client.expectString)(output[_DNSN]);
+  }
+  return contents;
+}, "de_CreateAccessPointOutput");
+var de_CreateAppCookieStickinessPolicyOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_CreateAppCookieStickinessPolicyOutput");
+var de_CreateLBCookieStickinessPolicyOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_CreateLBCookieStickinessPolicyOutput");
+var de_CreateLoadBalancerListenerOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_CreateLoadBalancerListenerOutput");
+var de_CreateLoadBalancerPolicyOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_CreateLoadBalancerPolicyOutput");
+var de_CrossZoneLoadBalancing = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_E] != null) {
+    contents[_E] = (0, import_smithy_client.parseBoolean)(output[_E]);
+  }
+  return contents;
+}, "de_CrossZoneLoadBalancing");
+var de_DeleteAccessPointOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_DeleteAccessPointOutput");
+var de_DeleteLoadBalancerListenerOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_DeleteLoadBalancerListenerOutput");
+var de_DeleteLoadBalancerPolicyOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_DeleteLoadBalancerPolicyOutput");
+var de_DependencyThrottleException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_DependencyThrottleException");
+var de_DeregisterEndPointsOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.Instances === "") {
+    contents[_I] = [];
+  } else if (output[_I] != null && output[_I][_m] != null) {
+    contents[_I] = de_Instances((0, import_smithy_client.getArrayIfSingleItem)(output[_I][_m]), context);
+  }
+  return contents;
+}, "de_DeregisterEndPointsOutput");
+var de_DescribeAccessPointsOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.LoadBalancerDescriptions === "") {
+    contents[_LBD] = [];
+  } else if (output[_LBD] != null && output[_LBD][_m] != null) {
+    contents[_LBD] = de_LoadBalancerDescriptions((0, import_smithy_client.getArrayIfSingleItem)(output[_LBD][_m]), context);
+  }
+  if (output[_NM] != null) {
+    contents[_NM] = (0, import_smithy_client.expectString)(output[_NM]);
+  }
+  return contents;
+}, "de_DescribeAccessPointsOutput");
+var de_DescribeAccountLimitsOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.Limits === "") {
+    contents[_Li] = [];
+  } else if (output[_Li] != null && output[_Li][_m] != null) {
+    contents[_Li] = de_Limits((0, import_smithy_client.getArrayIfSingleItem)(output[_Li][_m]), context);
+  }
+  if (output[_NM] != null) {
+    contents[_NM] = (0, import_smithy_client.expectString)(output[_NM]);
+  }
+  return contents;
+}, "de_DescribeAccountLimitsOutput");
+var de_DescribeEndPointStateOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.InstanceStates === "") {
+    contents[_IS] = [];
+  } else if (output[_IS] != null && output[_IS][_m] != null) {
+    contents[_IS] = de_InstanceStates((0, import_smithy_client.getArrayIfSingleItem)(output[_IS][_m]), context);
+  }
+  return contents;
+}, "de_DescribeEndPointStateOutput");
+var de_DescribeLoadBalancerAttributesOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_LBA] != null) {
+    contents[_LBA] = de_LoadBalancerAttributes(output[_LBA], context);
+  }
+  return contents;
+}, "de_DescribeLoadBalancerAttributesOutput");
+var de_DescribeLoadBalancerPoliciesOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.PolicyDescriptions === "") {
+    contents[_PD] = [];
+  } else if (output[_PD] != null && output[_PD][_m] != null) {
+    contents[_PD] = de_PolicyDescriptions((0, import_smithy_client.getArrayIfSingleItem)(output[_PD][_m]), context);
+  }
+  return contents;
+}, "de_DescribeLoadBalancerPoliciesOutput");
+var de_DescribeLoadBalancerPolicyTypesOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.PolicyTypeDescriptions === "") {
+    contents[_PTD] = [];
+  } else if (output[_PTD] != null && output[_PTD][_m] != null) {
+    contents[_PTD] = de_PolicyTypeDescriptions((0, import_smithy_client.getArrayIfSingleItem)(output[_PTD][_m]), context);
+  }
+  return contents;
+}, "de_DescribeLoadBalancerPolicyTypesOutput");
+var de_DescribeTagsOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.TagDescriptions === "") {
+    contents[_TD] = [];
+  } else if (output[_TD] != null && output[_TD][_m] != null) {
+    contents[_TD] = de_TagDescriptions((0, import_smithy_client.getArrayIfSingleItem)(output[_TD][_m]), context);
+  }
+  return contents;
+}, "de_DescribeTagsOutput");
+var de_DetachLoadBalancerFromSubnetsOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.Subnets === "") {
+    contents[_S] = [];
+  } else if (output[_S] != null && output[_S][_m] != null) {
+    contents[_S] = de_Subnets((0, import_smithy_client.getArrayIfSingleItem)(output[_S][_m]), context);
+  }
+  return contents;
+}, "de_DetachLoadBalancerFromSubnetsOutput");
+var de_DuplicateAccessPointNameException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_DuplicateAccessPointNameException");
+var de_DuplicateListenerException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_DuplicateListenerException");
+var de_DuplicatePolicyNameException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_DuplicatePolicyNameException");
+var de_DuplicateTagKeysException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_DuplicateTagKeysException");
+var de_HealthCheck = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Ta] != null) {
+    contents[_Ta] = (0, import_smithy_client.expectString)(output[_Ta]);
+  }
+  if (output[_In] != null) {
+    contents[_In] = (0, import_smithy_client.strictParseInt32)(output[_In]);
+  }
+  if (output[_Ti] != null) {
+    contents[_Ti] = (0, import_smithy_client.strictParseInt32)(output[_Ti]);
+  }
+  if (output[_UT] != null) {
+    contents[_UT] = (0, import_smithy_client.strictParseInt32)(output[_UT]);
+  }
+  if (output[_HT] != null) {
+    contents[_HT] = (0, import_smithy_client.strictParseInt32)(output[_HT]);
+  }
+  return contents;
+}, "de_HealthCheck");
+var de_Instance = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_II] != null) {
+    contents[_II] = (0, import_smithy_client.expectString)(output[_II]);
+  }
+  return contents;
+}, "de_Instance");
+var de_Instances = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_Instance(entry, context);
+  });
+}, "de_Instances");
+var de_InstanceState = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_II] != null) {
+    contents[_II] = (0, import_smithy_client.expectString)(output[_II]);
+  }
+  if (output[_St] != null) {
+    contents[_St] = (0, import_smithy_client.expectString)(output[_St]);
+  }
+  if (output[_RC] != null) {
+    contents[_RC] = (0, import_smithy_client.expectString)(output[_RC]);
+  }
+  if (output[_D] != null) {
+    contents[_D] = (0, import_smithy_client.expectString)(output[_D]);
+  }
+  return contents;
+}, "de_InstanceState");
+var de_InstanceStates = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_InstanceState(entry, context);
+  });
+}, "de_InstanceStates");
+var de_InvalidConfigurationRequestException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_InvalidConfigurationRequestException");
+var de_InvalidEndPointException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_InvalidEndPointException");
+var de_InvalidSchemeException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_InvalidSchemeException");
+var de_InvalidSecurityGroupException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_InvalidSecurityGroupException");
+var de_InvalidSubnetException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_InvalidSubnetException");
+var de_LBCookieStickinessPolicies = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_LBCookieStickinessPolicy(entry, context);
+  });
+}, "de_LBCookieStickinessPolicies");
+var de_LBCookieStickinessPolicy = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_PN] != null) {
+    contents[_PN] = (0, import_smithy_client.expectString)(output[_PN]);
+  }
+  if (output[_CEP] != null) {
+    contents[_CEP] = (0, import_smithy_client.strictParseLong)(output[_CEP]);
+  }
+  return contents;
+}, "de_LBCookieStickinessPolicy");
+var de_Limit = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_N] != null) {
+    contents[_N] = (0, import_smithy_client.expectString)(output[_N]);
+  }
+  if (output[_Ma] != null) {
+    contents[_Ma] = (0, import_smithy_client.expectString)(output[_Ma]);
+  }
+  return contents;
+}, "de_Limit");
+var de_Limits = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_Limit(entry, context);
+  });
+}, "de_Limits");
+var de_Listener = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_P] != null) {
+    contents[_P] = (0, import_smithy_client.expectString)(output[_P]);
+  }
+  if (output[_LBPo] != null) {
+    contents[_LBPo] = (0, import_smithy_client.strictParseInt32)(output[_LBPo]);
+  }
+  if (output[_IP] != null) {
+    contents[_IP] = (0, import_smithy_client.expectString)(output[_IP]);
+  }
+  if (output[_IPn] != null) {
+    contents[_IPn] = (0, import_smithy_client.strictParseInt32)(output[_IPn]);
+  }
+  if (output[_SSLCI] != null) {
+    contents[_SSLCI] = (0, import_smithy_client.expectString)(output[_SSLCI]);
+  }
+  return contents;
+}, "de_Listener");
+var de_ListenerDescription = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Lis] != null) {
+    contents[_Lis] = de_Listener(output[_Lis], context);
+  }
+  if (output.PolicyNames === "") {
+    contents[_PNo] = [];
+  } else if (output[_PNo] != null && output[_PNo][_m] != null) {
+    contents[_PNo] = de_PolicyNames((0, import_smithy_client.getArrayIfSingleItem)(output[_PNo][_m]), context);
+  }
+  return contents;
+}, "de_ListenerDescription");
+var de_ListenerDescriptions = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_ListenerDescription(entry, context);
+  });
+}, "de_ListenerDescriptions");
+var de_ListenerNotFoundException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_ListenerNotFoundException");
+var de_LoadBalancerAttributeNotFoundException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_LoadBalancerAttributeNotFoundException");
+var de_LoadBalancerAttributes = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_CZLB] != null) {
+    contents[_CZLB] = de_CrossZoneLoadBalancing(output[_CZLB], context);
+  }
+  if (output[_AL] != null) {
+    contents[_AL] = de_AccessLog(output[_AL], context);
+  }
+  if (output[_CD] != null) {
+    contents[_CD] = de_ConnectionDraining(output[_CD], context);
+  }
+  if (output[_CS] != null) {
+    contents[_CS] = de_ConnectionSettings(output[_CS], context);
+  }
+  if (output.AdditionalAttributes === "") {
+    contents[_AA] = [];
+  } else if (output[_AA] != null && output[_AA][_m] != null) {
+    contents[_AA] = de_AdditionalAttributes((0, import_smithy_client.getArrayIfSingleItem)(output[_AA][_m]), context);
+  }
+  return contents;
+}, "de_LoadBalancerAttributes");
+var de_LoadBalancerDescription = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_LBN] != null) {
+    contents[_LBN] = (0, import_smithy_client.expectString)(output[_LBN]);
+  }
+  if (output[_DNSN] != null) {
+    contents[_DNSN] = (0, import_smithy_client.expectString)(output[_DNSN]);
+  }
+  if (output[_CHZN] != null) {
+    contents[_CHZN] = (0, import_smithy_client.expectString)(output[_CHZN]);
+  }
+  if (output[_CHZNID] != null) {
+    contents[_CHZNID] = (0, import_smithy_client.expectString)(output[_CHZNID]);
+  }
+  if (output.ListenerDescriptions === "") {
+    contents[_LD] = [];
+  } else if (output[_LD] != null && output[_LD][_m] != null) {
+    contents[_LD] = de_ListenerDescriptions((0, import_smithy_client.getArrayIfSingleItem)(output[_LD][_m]), context);
+  }
+  if (output[_Po] != null) {
+    contents[_Po] = de_Policies(output[_Po], context);
+  }
+  if (output.BackendServerDescriptions === "") {
+    contents[_BSD] = [];
+  } else if (output[_BSD] != null && output[_BSD][_m] != null) {
+    contents[_BSD] = de_BackendServerDescriptions((0, import_smithy_client.getArrayIfSingleItem)(output[_BSD][_m]), context);
+  }
+  if (output.AvailabilityZones === "") {
+    contents[_AZ] = [];
+  } else if (output[_AZ] != null && output[_AZ][_m] != null) {
+    contents[_AZ] = de_AvailabilityZones((0, import_smithy_client.getArrayIfSingleItem)(output[_AZ][_m]), context);
+  }
+  if (output.Subnets === "") {
+    contents[_S] = [];
+  } else if (output[_S] != null && output[_S][_m] != null) {
+    contents[_S] = de_Subnets((0, import_smithy_client.getArrayIfSingleItem)(output[_S][_m]), context);
+  }
+  if (output[_VPCI] != null) {
+    contents[_VPCI] = (0, import_smithy_client.expectString)(output[_VPCI]);
+  }
+  if (output.Instances === "") {
+    contents[_I] = [];
+  } else if (output[_I] != null && output[_I][_m] != null) {
+    contents[_I] = de_Instances((0, import_smithy_client.getArrayIfSingleItem)(output[_I][_m]), context);
+  }
+  if (output[_HC] != null) {
+    contents[_HC] = de_HealthCheck(output[_HC], context);
+  }
+  if (output[_SSG] != null) {
+    contents[_SSG] = de_SourceSecurityGroup(output[_SSG], context);
+  }
+  if (output.SecurityGroups === "") {
+    contents[_SG] = [];
+  } else if (output[_SG] != null && output[_SG][_m] != null) {
+    contents[_SG] = de_SecurityGroups((0, import_smithy_client.getArrayIfSingleItem)(output[_SG][_m]), context);
+  }
+  if (output[_CT] != null) {
+    contents[_CT] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_CT]));
+  }
+  if (output[_Sc] != null) {
+    contents[_Sc] = (0, import_smithy_client.expectString)(output[_Sc]);
+  }
+  return contents;
+}, "de_LoadBalancerDescription");
+var de_LoadBalancerDescriptions = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_LoadBalancerDescription(entry, context);
+  });
+}, "de_LoadBalancerDescriptions");
+var de_ModifyLoadBalancerAttributesOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_LBN] != null) {
+    contents[_LBN] = (0, import_smithy_client.expectString)(output[_LBN]);
+  }
+  if (output[_LBA] != null) {
+    contents[_LBA] = de_LoadBalancerAttributes(output[_LBA], context);
+  }
+  return contents;
+}, "de_ModifyLoadBalancerAttributesOutput");
+var de_OperationNotPermittedException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_OperationNotPermittedException");
+var de_Policies = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.AppCookieStickinessPolicies === "") {
+    contents[_ACSP] = [];
+  } else if (output[_ACSP] != null && output[_ACSP][_m] != null) {
+    contents[_ACSP] = de_AppCookieStickinessPolicies((0, import_smithy_client.getArrayIfSingleItem)(output[_ACSP][_m]), context);
+  }
+  if (output.LBCookieStickinessPolicies === "") {
+    contents[_LBCSP] = [];
+  } else if (output[_LBCSP] != null && output[_LBCSP][_m] != null) {
+    contents[_LBCSP] = de_LBCookieStickinessPolicies((0, import_smithy_client.getArrayIfSingleItem)(output[_LBCSP][_m]), context);
+  }
+  if (output.OtherPolicies === "") {
+    contents[_OP] = [];
+  } else if (output[_OP] != null && output[_OP][_m] != null) {
+    contents[_OP] = de_PolicyNames((0, import_smithy_client.getArrayIfSingleItem)(output[_OP][_m]), context);
+  }
+  return contents;
+}, "de_Policies");
+var de_PolicyAttributeDescription = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_AN] != null) {
+    contents[_AN] = (0, import_smithy_client.expectString)(output[_AN]);
+  }
+  if (output[_AV] != null) {
+    contents[_AV] = (0, import_smithy_client.expectString)(output[_AV]);
+  }
+  return contents;
+}, "de_PolicyAttributeDescription");
+var de_PolicyAttributeDescriptions = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_PolicyAttributeDescription(entry, context);
+  });
+}, "de_PolicyAttributeDescriptions");
+var de_PolicyAttributeTypeDescription = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_AN] != null) {
+    contents[_AN] = (0, import_smithy_client.expectString)(output[_AN]);
+  }
+  if (output[_ATt] != null) {
+    contents[_ATt] = (0, import_smithy_client.expectString)(output[_ATt]);
+  }
+  if (output[_D] != null) {
+    contents[_D] = (0, import_smithy_client.expectString)(output[_D]);
+  }
+  if (output[_DV] != null) {
+    contents[_DV] = (0, import_smithy_client.expectString)(output[_DV]);
+  }
+  if (output[_C] != null) {
+    contents[_C] = (0, import_smithy_client.expectString)(output[_C]);
+  }
+  return contents;
+}, "de_PolicyAttributeTypeDescription");
+var de_PolicyAttributeTypeDescriptions = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_PolicyAttributeTypeDescription(entry, context);
+  });
+}, "de_PolicyAttributeTypeDescriptions");
+var de_PolicyDescription = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_PN] != null) {
+    contents[_PN] = (0, import_smithy_client.expectString)(output[_PN]);
+  }
+  if (output[_PTN] != null) {
+    contents[_PTN] = (0, import_smithy_client.expectString)(output[_PTN]);
+  }
+  if (output.PolicyAttributeDescriptions === "") {
+    contents[_PAD] = [];
+  } else if (output[_PAD] != null && output[_PAD][_m] != null) {
+    contents[_PAD] = de_PolicyAttributeDescriptions((0, import_smithy_client.getArrayIfSingleItem)(output[_PAD][_m]), context);
+  }
+  return contents;
+}, "de_PolicyDescription");
+var de_PolicyDescriptions = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_PolicyDescription(entry, context);
+  });
+}, "de_PolicyDescriptions");
+var de_PolicyNames = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.expectString)(entry);
+  });
+}, "de_PolicyNames");
+var de_PolicyNotFoundException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_PolicyNotFoundException");
+var de_PolicyTypeDescription = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_PTN] != null) {
+    contents[_PTN] = (0, import_smithy_client.expectString)(output[_PTN]);
+  }
+  if (output[_D] != null) {
+    contents[_D] = (0, import_smithy_client.expectString)(output[_D]);
+  }
+  if (output.PolicyAttributeTypeDescriptions === "") {
+    contents[_PATD] = [];
+  } else if (output[_PATD] != null && output[_PATD][_m] != null) {
+    contents[_PATD] = de_PolicyAttributeTypeDescriptions((0, import_smithy_client.getArrayIfSingleItem)(output[_PATD][_m]), context);
+  }
+  return contents;
+}, "de_PolicyTypeDescription");
+var de_PolicyTypeDescriptions = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_PolicyTypeDescription(entry, context);
+  });
+}, "de_PolicyTypeDescriptions");
+var de_PolicyTypeNotFoundException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_PolicyTypeNotFoundException");
+var de_RegisterEndPointsOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.Instances === "") {
+    contents[_I] = [];
+  } else if (output[_I] != null && output[_I][_m] != null) {
+    contents[_I] = de_Instances((0, import_smithy_client.getArrayIfSingleItem)(output[_I][_m]), context);
+  }
+  return contents;
+}, "de_RegisterEndPointsOutput");
+var de_RemoveAvailabilityZonesOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output.AvailabilityZones === "") {
+    contents[_AZ] = [];
+  } else if (output[_AZ] != null && output[_AZ][_m] != null) {
+    contents[_AZ] = de_AvailabilityZones((0, import_smithy_client.getArrayIfSingleItem)(output[_AZ][_m]), context);
+  }
+  return contents;
+}, "de_RemoveAvailabilityZonesOutput");
+var de_RemoveTagsOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_RemoveTagsOutput");
+var de_SecurityGroups = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.expectString)(entry);
+  });
+}, "de_SecurityGroups");
+var de_SetLoadBalancerListenerSSLCertificateOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_SetLoadBalancerListenerSSLCertificateOutput");
+var de_SetLoadBalancerPoliciesForBackendServerOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_SetLoadBalancerPoliciesForBackendServerOutput");
+var de_SetLoadBalancerPoliciesOfListenerOutput = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  return contents;
+}, "de_SetLoadBalancerPoliciesOfListenerOutput");
+var de_SourceSecurityGroup = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_OA] != null) {
+    contents[_OA] = (0, import_smithy_client.expectString)(output[_OA]);
+  }
+  if (output[_GN] != null) {
+    contents[_GN] = (0, import_smithy_client.expectString)(output[_GN]);
+  }
+  return contents;
+}, "de_SourceSecurityGroup");
+var de_SubnetNotFoundException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_SubnetNotFoundException");
+var de_Subnets = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return (0, import_smithy_client.expectString)(entry);
+  });
+}, "de_Subnets");
+var de_Tag = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_K] != null) {
+    contents[_K] = (0, import_smithy_client.expectString)(output[_K]);
+  }
+  if (output[_Va] != null) {
+    contents[_Va] = (0, import_smithy_client.expectString)(output[_Va]);
+  }
+  return contents;
+}, "de_Tag");
+var de_TagDescription = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_LBN] != null) {
+    contents[_LBN] = (0, import_smithy_client.expectString)(output[_LBN]);
+  }
+  if (output.Tags === "") {
+    contents[_T] = [];
+  } else if (output[_T] != null && output[_T][_m] != null) {
+    contents[_T] = de_TagList((0, import_smithy_client.getArrayIfSingleItem)(output[_T][_m]), context);
+  }
+  return contents;
+}, "de_TagDescription");
+var de_TagDescriptions = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_TagDescription(entry, context);
+  });
+}, "de_TagDescriptions");
+var de_TagList = /* @__PURE__ */ __name((output, context) => {
+  return (output || []).filter((e) => e != null).map((entry) => {
+    return de_Tag(entry, context);
+  });
+}, "de_TagList");
+var de_TooManyAccessPointsException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_TooManyAccessPointsException");
+var de_TooManyPoliciesException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_TooManyPoliciesException");
+var de_TooManyTagsException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_TooManyTagsException");
+var de_UnsupportedProtocolException = /* @__PURE__ */ __name((output, context) => {
+  const contents = {};
+  if (output[_Me] != null) {
+    contents[_Me] = (0, import_smithy_client.expectString)(output[_Me]);
+  }
+  return contents;
+}, "de_UnsupportedProtocolException");
+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)(ElasticLoadBalancingServiceException);
+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");
+var SHARED_HEADERS = {
+  "content-type": "application/x-www-form-urlencoded"
+};
+var _ = "2012-06-01";
+var _A = "Action";
+var _AA = "AdditionalAttributes";
+var _ACSP = "AppCookieStickinessPolicies";
+var _AL = "AccessLog";
+var _ALBTS = "AttachLoadBalancerToSubnets";
+var _AN = "AttributeName";
+var _ASGTLB = "ApplySecurityGroupsToLoadBalancer";
+var _AT = "AddTags";
+var _ATt = "AttributeType";
+var _AV = "AttributeValue";
+var _AZ = "AvailabilityZones";
+var _BSD = "BackendServerDescriptions";
+var _C = "Cardinality";
+var _CACSP = "CreateAppCookieStickinessPolicy";
+var _CD = "ConnectionDraining";
+var _CEP = "CookieExpirationPeriod";
+var _CHC = "ConfigureHealthCheck";
+var _CHZN = "CanonicalHostedZoneName";
+var _CHZNID = "CanonicalHostedZoneNameID";
+var _CLB = "CreateLoadBalancer";
+var _CLBCSP = "CreateLBCookieStickinessPolicy";
+var _CLBL = "CreateLoadBalancerListeners";
+var _CLBP = "CreateLoadBalancerPolicy";
+var _CN = "CookieName";
+var _CS = "ConnectionSettings";
+var _CT = "CreatedTime";
+var _CZLB = "CrossZoneLoadBalancing";
+var _D = "Description";
+var _DAL = "DescribeAccountLimits";
+var _DAZFLB = "DisableAvailabilityZonesForLoadBalancer";
+var _DIFLB = "DeregisterInstancesFromLoadBalancer";
+var _DIH = "DescribeInstanceHealth";
+var _DLB = "DeleteLoadBalancer";
+var _DLBA = "DescribeLoadBalancerAttributes";
+var _DLBFS = "DetachLoadBalancerFromSubnets";
+var _DLBL = "DeleteLoadBalancerListeners";
+var _DLBP = "DeleteLoadBalancerPolicy";
+var _DLBPT = "DescribeLoadBalancerPolicyTypes";
+var _DLBPe = "DescribeLoadBalancerPolicies";
+var _DLBe = "DescribeLoadBalancers";
+var _DNSN = "DNSName";
+var _DT = "DescribeTags";
+var _DV = "DefaultValue";
+var _E = "Enabled";
+var _EAZFLB = "EnableAvailabilityZonesForLoadBalancer";
+var _EI = "EmitInterval";
+var _GN = "GroupName";
+var _HC = "HealthCheck";
+var _HT = "HealthyThreshold";
+var _I = "Instances";
+var _II = "InstanceId";
+var _IP = "InstanceProtocol";
+var _IPn = "InstancePort";
+var _IS = "InstanceStates";
+var _IT = "IdleTimeout";
+var _In = "Interval";
+var _K = "Key";
+var _L = "Listeners";
+var _LBA = "LoadBalancerAttributes";
+var _LBCSP = "LBCookieStickinessPolicies";
+var _LBD = "LoadBalancerDescriptions";
+var _LBN = "LoadBalancerName";
+var _LBNo = "LoadBalancerNames";
+var _LBP = "LoadBalancerPorts";
+var _LBPo = "LoadBalancerPort";
+var _LD = "ListenerDescriptions";
+var _Li = "Limits";
+var _Lis = "Listener";
+var _M = "Marker";
+var _MLBA = "ModifyLoadBalancerAttributes";
+var _Ma = "Max";
+var _Me = "Message";
+var _N = "Name";
+var _NM = "NextMarker";
+var _OA = "OwnerAlias";
+var _OP = "OtherPolicies";
+var _P = "Protocol";
+var _PA = "PolicyAttributes";
+var _PAD = "PolicyAttributeDescriptions";
+var _PATD = "PolicyAttributeTypeDescriptions";
+var _PD = "PolicyDescriptions";
+var _PN = "PolicyName";
+var _PNo = "PolicyNames";
+var _PS = "PageSize";
+var _PTD = "PolicyTypeDescriptions";
+var _PTN = "PolicyTypeName";
+var _PTNo = "PolicyTypeNames";
+var _Po = "Policies";
+var _RC = "ReasonCode";
+var _RIWLB = "RegisterInstancesWithLoadBalancer";
+var _RT = "RemoveTags";
+var _S = "Subnets";
+var _SBN = "S3BucketName";
+var _SBP = "S3BucketPrefix";
+var _SG = "SecurityGroups";
+var _SLBLSSLC = "SetLoadBalancerListenerSSLCertificate";
+var _SLBPFBS = "SetLoadBalancerPoliciesForBackendServer";
+var _SLBPOL = "SetLoadBalancerPoliciesOfListener";
+var _SSG = "SourceSecurityGroup";
+var _SSLCI = "SSLCertificateId";
+var _Sc = "Scheme";
+var _St = "State";
+var _T = "Tags";
+var _TD = "TagDescriptions";
+var _Ta = "Target";
+var _Ti = "Timeout";
+var _UT = "UnhealthyThreshold";
+var _V = "Version";
+var _VPCI = "VPCId";
+var _Va = "Value";
+var _m = "member";
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    const parser = new import_fast_xml_parser.XMLParser({
+      attributeNamePrefix: "",
+      htmlEntities: true,
+      ignoreAttributes: false,
+      ignoreDeclaration: true,
+      parseTagValue: false,
+      trimValues: false,
+      tagValueProcessor: (_2, val) => val.trim() === "" && val.includes("\n") ? "" : void 0
+    });
+    parser.addEntity("#xD", "\r");
+    parser.addEntity("#10", "\n");
+    const parsedObj = parser.parse(encoded);
+    const textNodeName = "#text";
+    const key = Object.keys(parsedObj)[0];
+    const parsedObjToReturn = parsedObj[key];
+    if (parsedObjToReturn[textNodeName]) {
+      parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
+      delete parsedObjToReturn[textNodeName];
+    }
+    return (0, import_smithy_client.getValueFromTextNode)(parsedObjToReturn);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  if (value.Error) {
+    value.Error.message = value.Error.message ?? value.Error.Message;
+  }
+  return value;
+}, "parseErrorBody");
+var buildFormUrlencodedString = /* @__PURE__ */ __name((formEntries) => Object.entries(formEntries).map(([key, value]) => (0, import_smithy_client.extendedEncodeURIComponent)(key) + "=" + (0, import_smithy_client.extendedEncodeURIComponent)(value)).join("&"), "buildFormUrlencodedString");
+var loadQueryErrorCode = /* @__PURE__ */ __name((output, data) => {
+  var _a;
+  if (((_a = data.Error) == null ? void 0 : _a.Code) !== void 0) {
+    return data.Error.Code;
+  }
+  if (output.statusCode == 404) {
+    return "NotFound";
+  }
+}, "loadQueryErrorCode");
+
+// src/commands/AddTagsCommand.ts
+var _AddTagsCommand = class _AddTagsCommand 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("ElasticLoadBalancing_v7", "AddTags", {}).n("ElasticLoadBalancingClient", "AddTagsCommand").f(void 0, void 0).ser(se_AddTagsCommand).de(de_AddTagsCommand).build() {
+};
+__name(_AddTagsCommand, "AddTagsCommand");
+var AddTagsCommand = _AddTagsCommand;
+
+// src/commands/ApplySecurityGroupsToLoadBalancerCommand.ts
+
+
+
+
+var _ApplySecurityGroupsToLoadBalancerCommand = class _ApplySecurityGroupsToLoadBalancerCommand 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("ElasticLoadBalancing_v7", "ApplySecurityGroupsToLoadBalancer", {}).n("ElasticLoadBalancingClient", "ApplySecurityGroupsToLoadBalancerCommand").f(void 0, void 0).ser(se_ApplySecurityGroupsToLoadBalancerCommand).de(de_ApplySecurityGroupsToLoadBalancerCommand).build() {
+};
+__name(_ApplySecurityGroupsToLoadBalancerCommand, "ApplySecurityGroupsToLoadBalancerCommand");
+var ApplySecurityGroupsToLoadBalancerCommand = _ApplySecurityGroupsToLoadBalancerCommand;
+
+// src/commands/AttachLoadBalancerToSubnetsCommand.ts
+
+
+
+
+var _AttachLoadBalancerToSubnetsCommand = class _AttachLoadBalancerToSubnetsCommand 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("ElasticLoadBalancing_v7", "AttachLoadBalancerToSubnets", {}).n("ElasticLoadBalancingClient", "AttachLoadBalancerToSubnetsCommand").f(void 0, void 0).ser(se_AttachLoadBalancerToSubnetsCommand).de(de_AttachLoadBalancerToSubnetsCommand).build() {
+};
+__name(_AttachLoadBalancerToSubnetsCommand, "AttachLoadBalancerToSubnetsCommand");
+var AttachLoadBalancerToSubnetsCommand = _AttachLoadBalancerToSubnetsCommand;
+
+// src/commands/ConfigureHealthCheckCommand.ts
+
+
+
+
+var _ConfigureHealthCheckCommand = class _ConfigureHealthCheckCommand 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("ElasticLoadBalancing_v7", "ConfigureHealthCheck", {}).n("ElasticLoadBalancingClient", "ConfigureHealthCheckCommand").f(void 0, void 0).ser(se_ConfigureHealthCheckCommand).de(de_ConfigureHealthCheckCommand).build() {
+};
+__name(_ConfigureHealthCheckCommand, "ConfigureHealthCheckCommand");
+var ConfigureHealthCheckCommand = _ConfigureHealthCheckCommand;
+
+// src/commands/CreateAppCookieStickinessPolicyCommand.ts
+
+
+
+
+var _CreateAppCookieStickinessPolicyCommand = class _CreateAppCookieStickinessPolicyCommand 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("ElasticLoadBalancing_v7", "CreateAppCookieStickinessPolicy", {}).n("ElasticLoadBalancingClient", "CreateAppCookieStickinessPolicyCommand").f(void 0, void 0).ser(se_CreateAppCookieStickinessPolicyCommand).de(de_CreateAppCookieStickinessPolicyCommand).build() {
+};
+__name(_CreateAppCookieStickinessPolicyCommand, "CreateAppCookieStickinessPolicyCommand");
+var CreateAppCookieStickinessPolicyCommand = _CreateAppCookieStickinessPolicyCommand;
+
+// src/commands/CreateLBCookieStickinessPolicyCommand.ts
+
+
+
+
+var _CreateLBCookieStickinessPolicyCommand = class _CreateLBCookieStickinessPolicyCommand 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("ElasticLoadBalancing_v7", "CreateLBCookieStickinessPolicy", {}).n("ElasticLoadBalancingClient", "CreateLBCookieStickinessPolicyCommand").f(void 0, void 0).ser(se_CreateLBCookieStickinessPolicyCommand).de(de_CreateLBCookieStickinessPolicyCommand).build() {
+};
+__name(_CreateLBCookieStickinessPolicyCommand, "CreateLBCookieStickinessPolicyCommand");
+var CreateLBCookieStickinessPolicyCommand = _CreateLBCookieStickinessPolicyCommand;
+
+// src/commands/CreateLoadBalancerCommand.ts
+
+
+
+
+var _CreateLoadBalancerCommand = class _CreateLoadBalancerCommand 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("ElasticLoadBalancing_v7", "CreateLoadBalancer", {}).n("ElasticLoadBalancingClient", "CreateLoadBalancerCommand").f(void 0, void 0).ser(se_CreateLoadBalancerCommand).de(de_CreateLoadBalancerCommand).build() {
+};
+__name(_CreateLoadBalancerCommand, "CreateLoadBalancerCommand");
+var CreateLoadBalancerCommand = _CreateLoadBalancerCommand;
+
+// src/commands/CreateLoadBalancerListenersCommand.ts
+
+
+
+
+var _CreateLoadBalancerListenersCommand = class _CreateLoadBalancerListenersCommand 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("ElasticLoadBalancing_v7", "CreateLoadBalancerListeners", {}).n("ElasticLoadBalancingClient", "CreateLoadBalancerListenersCommand").f(void 0, void 0).ser(se_CreateLoadBalancerListenersCommand).de(de_CreateLoadBalancerListenersCommand).build() {
+};
+__name(_CreateLoadBalancerListenersCommand, "CreateLoadBalancerListenersCommand");
+var CreateLoadBalancerListenersCommand = _CreateLoadBalancerListenersCommand;
+
+// src/commands/CreateLoadBalancerPolicyCommand.ts
+
+
+
+
+var _CreateLoadBalancerPolicyCommand = class _CreateLoadBalancerPolicyCommand 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("ElasticLoadBalancing_v7", "CreateLoadBalancerPolicy", {}).n("ElasticLoadBalancingClient", "CreateLoadBalancerPolicyCommand").f(void 0, void 0).ser(se_CreateLoadBalancerPolicyCommand).de(de_CreateLoadBalancerPolicyCommand).build() {
+};
+__name(_CreateLoadBalancerPolicyCommand, "CreateLoadBalancerPolicyCommand");
+var CreateLoadBalancerPolicyCommand = _CreateLoadBalancerPolicyCommand;
+
+// src/commands/DeleteLoadBalancerCommand.ts
+
+
+
+
+var _DeleteLoadBalancerCommand = class _DeleteLoadBalancerCommand 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("ElasticLoadBalancing_v7", "DeleteLoadBalancer", {}).n("ElasticLoadBalancingClient", "DeleteLoadBalancerCommand").f(void 0, void 0).ser(se_DeleteLoadBalancerCommand).de(de_DeleteLoadBalancerCommand).build() {
+};
+__name(_DeleteLoadBalancerCommand, "DeleteLoadBalancerCommand");
+var DeleteLoadBalancerCommand = _DeleteLoadBalancerCommand;
+
+// src/commands/DeleteLoadBalancerListenersCommand.ts
+
+
+
+
+var _DeleteLoadBalancerListenersCommand = class _DeleteLoadBalancerListenersCommand 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("ElasticLoadBalancing_v7", "DeleteLoadBalancerListeners", {}).n("ElasticLoadBalancingClient", "DeleteLoadBalancerListenersCommand").f(void 0, void 0).ser(se_DeleteLoadBalancerListenersCommand).de(de_DeleteLoadBalancerListenersCommand).build() {
+};
+__name(_DeleteLoadBalancerListenersCommand, "DeleteLoadBalancerListenersCommand");
+var DeleteLoadBalancerListenersCommand = _DeleteLoadBalancerListenersCommand;
+
+// src/commands/DeleteLoadBalancerPolicyCommand.ts
+
+
+
+
+var _DeleteLoadBalancerPolicyCommand = class _DeleteLoadBalancerPolicyCommand 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("ElasticLoadBalancing_v7", "DeleteLoadBalancerPolicy", {}).n("ElasticLoadBalancingClient", "DeleteLoadBalancerPolicyCommand").f(void 0, void 0).ser(se_DeleteLoadBalancerPolicyCommand).de(de_DeleteLoadBalancerPolicyCommand).build() {
+};
+__name(_DeleteLoadBalancerPolicyCommand, "DeleteLoadBalancerPolicyCommand");
+var DeleteLoadBalancerPolicyCommand = _DeleteLoadBalancerPolicyCommand;
+
+// src/commands/DeregisterInstancesFromLoadBalancerCommand.ts
+
+
+
+
+var _DeregisterInstancesFromLoadBalancerCommand = class _DeregisterInstancesFromLoadBalancerCommand 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("ElasticLoadBalancing_v7", "DeregisterInstancesFromLoadBalancer", {}).n("ElasticLoadBalancingClient", "DeregisterInstancesFromLoadBalancerCommand").f(void 0, void 0).ser(se_DeregisterInstancesFromLoadBalancerCommand).de(de_DeregisterInstancesFromLoadBalancerCommand).build() {
+};
+__name(_DeregisterInstancesFromLoadBalancerCommand, "DeregisterInstancesFromLoadBalancerCommand");
+var DeregisterInstancesFromLoadBalancerCommand = _DeregisterInstancesFromLoadBalancerCommand;
+
+// src/commands/DescribeAccountLimitsCommand.ts
+
+
+
+
+var _DescribeAccountLimitsCommand = class _DescribeAccountLimitsCommand 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("ElasticLoadBalancing_v7", "DescribeAccountLimits", {}).n("ElasticLoadBalancingClient", "DescribeAccountLimitsCommand").f(void 0, void 0).ser(se_DescribeAccountLimitsCommand).de(de_DescribeAccountLimitsCommand).build() {
+};
+__name(_DescribeAccountLimitsCommand, "DescribeAccountLimitsCommand");
+var DescribeAccountLimitsCommand = _DescribeAccountLimitsCommand;
+
+// src/commands/DescribeInstanceHealthCommand.ts
+
+
+
+
+var _DescribeInstanceHealthCommand = class _DescribeInstanceHealthCommand 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("ElasticLoadBalancing_v7", "DescribeInstanceHealth", {}).n("ElasticLoadBalancingClient", "DescribeInstanceHealthCommand").f(void 0, void 0).ser(se_DescribeInstanceHealthCommand).de(de_DescribeInstanceHealthCommand).build() {
+};
+__name(_DescribeInstanceHealthCommand, "DescribeInstanceHealthCommand");
+var DescribeInstanceHealthCommand = _DescribeInstanceHealthCommand;
+
+// src/commands/DescribeLoadBalancerAttributesCommand.ts
+
+
+
+
+var _DescribeLoadBalancerAttributesCommand = class _DescribeLoadBalancerAttributesCommand 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("ElasticLoadBalancing_v7", "DescribeLoadBalancerAttributes", {}).n("ElasticLoadBalancingClient", "DescribeLoadBalancerAttributesCommand").f(void 0, void 0).ser(se_DescribeLoadBalancerAttributesCommand).de(de_DescribeLoadBalancerAttributesCommand).build() {
+};
+__name(_DescribeLoadBalancerAttributesCommand, "DescribeLoadBalancerAttributesCommand");
+var DescribeLoadBalancerAttributesCommand = _DescribeLoadBalancerAttributesCommand;
+
+// src/commands/DescribeLoadBalancerPoliciesCommand.ts
+
+
+
+
+var _DescribeLoadBalancerPoliciesCommand = class _DescribeLoadBalancerPoliciesCommand 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("ElasticLoadBalancing_v7", "DescribeLoadBalancerPolicies", {}).n("ElasticLoadBalancingClient", "DescribeLoadBalancerPoliciesCommand").f(void 0, void 0).ser(se_DescribeLoadBalancerPoliciesCommand).de(de_DescribeLoadBalancerPoliciesCommand).build() {
+};
+__name(_DescribeLoadBalancerPoliciesCommand, "DescribeLoadBalancerPoliciesCommand");
+var DescribeLoadBalancerPoliciesCommand = _DescribeLoadBalancerPoliciesCommand;
+
+// src/commands/DescribeLoadBalancerPolicyTypesCommand.ts
+
+
+
+
+var _DescribeLoadBalancerPolicyTypesCommand = class _DescribeLoadBalancerPolicyTypesCommand 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("ElasticLoadBalancing_v7", "DescribeLoadBalancerPolicyTypes", {}).n("ElasticLoadBalancingClient", "DescribeLoadBalancerPolicyTypesCommand").f(void 0, void 0).ser(se_DescribeLoadBalancerPolicyTypesCommand).de(de_DescribeLoadBalancerPolicyTypesCommand).build() {
+};
+__name(_DescribeLoadBalancerPolicyTypesCommand, "DescribeLoadBalancerPolicyTypesCommand");
+var DescribeLoadBalancerPolicyTypesCommand = _DescribeLoadBalancerPolicyTypesCommand;
+
+// src/commands/DescribeLoadBalancersCommand.ts
+
+
+
+
+var _DescribeLoadBalancersCommand = class _DescribeLoadBalancersCommand 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("ElasticLoadBalancing_v7", "DescribeLoadBalancers", {}).n("ElasticLoadBalancingClient", "DescribeLoadBalancersCommand").f(void 0, void 0).ser(se_DescribeLoadBalancersCommand).de(de_DescribeLoadBalancersCommand).build() {
+};
+__name(_DescribeLoadBalancersCommand, "DescribeLoadBalancersCommand");
+var DescribeLoadBalancersCommand = _DescribeLoadBalancersCommand;
+
+// src/commands/DescribeTagsCommand.ts
+
+
+
+
+var _DescribeTagsCommand = class _DescribeTagsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("ElasticLoadBalancing_v7", "DescribeTags", {}).n("ElasticLoadBalancingClient", "DescribeTagsCommand").f(void 0, void 0).ser(se_DescribeTagsCommand).de(de_DescribeTagsCommand).build() {
+};
+__name(_DescribeTagsCommand, "DescribeTagsCommand");
+var DescribeTagsCommand = _DescribeTagsCommand;
+
+// src/commands/DetachLoadBalancerFromSubnetsCommand.ts
+
+
+
+
+var _DetachLoadBalancerFromSubnetsCommand = class _DetachLoadBalancerFromSubnetsCommand 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("ElasticLoadBalancing_v7", "DetachLoadBalancerFromSubnets", {}).n("ElasticLoadBalancingClient", "DetachLoadBalancerFromSubnetsCommand").f(void 0, void 0).ser(se_DetachLoadBalancerFromSubnetsCommand).de(de_DetachLoadBalancerFromSubnetsCommand).build() {
+};
+__name(_DetachLoadBalancerFromSubnetsCommand, "DetachLoadBalancerFromSubnetsCommand");
+var DetachLoadBalancerFromSubnetsCommand = _DetachLoadBalancerFromSubnetsCommand;
+
+// src/commands/DisableAvailabilityZonesForLoadBalancerCommand.ts
+
+
+
+
+var _DisableAvailabilityZonesForLoadBalancerCommand = class _DisableAvailabilityZonesForLoadBalancerCommand 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("ElasticLoadBalancing_v7", "DisableAvailabilityZonesForLoadBalancer", {}).n("ElasticLoadBalancingClient", "DisableAvailabilityZonesForLoadBalancerCommand").f(void 0, void 0).ser(se_DisableAvailabilityZonesForLoadBalancerCommand).de(de_DisableAvailabilityZonesForLoadBalancerCommand).build() {
+};
+__name(_DisableAvailabilityZonesForLoadBalancerCommand, "DisableAvailabilityZonesForLoadBalancerCommand");
+var DisableAvailabilityZonesForLoadBalancerCommand = _DisableAvailabilityZonesForLoadBalancerCommand;
+
+// src/commands/EnableAvailabilityZonesForLoadBalancerCommand.ts
+
+
+
+
+var _EnableAvailabilityZonesForLoadBalancerCommand = class _EnableAvailabilityZonesForLoadBalancerCommand 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("ElasticLoadBalancing_v7", "EnableAvailabilityZonesForLoadBalancer", {}).n("ElasticLoadBalancingClient", "EnableAvailabilityZonesForLoadBalancerCommand").f(void 0, void 0).ser(se_EnableAvailabilityZonesForLoadBalancerCommand).de(de_EnableAvailabilityZonesForLoadBalancerCommand).build() {
+};
+__name(_EnableAvailabilityZonesForLoadBalancerCommand, "EnableAvailabilityZonesForLoadBalancerCommand");
+var EnableAvailabilityZonesForLoadBalancerCommand = _EnableAvailabilityZonesForLoadBalancerCommand;
+
+// src/commands/ModifyLoadBalancerAttributesCommand.ts
+
+
+
+
+var _ModifyLoadBalancerAttributesCommand = class _ModifyLoadBalancerAttributesCommand 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("ElasticLoadBalancing_v7", "ModifyLoadBalancerAttributes", {}).n("ElasticLoadBalancingClient", "ModifyLoadBalancerAttributesCommand").f(void 0, void 0).ser(se_ModifyLoadBalancerAttributesCommand).de(de_ModifyLoadBalancerAttributesCommand).build() {
+};
+__name(_ModifyLoadBalancerAttributesCommand, "ModifyLoadBalancerAttributesCommand");
+var ModifyLoadBalancerAttributesCommand = _ModifyLoadBalancerAttributesCommand;
+
+// src/commands/RegisterInstancesWithLoadBalancerCommand.ts
+
+
+
+
+var _RegisterInstancesWithLoadBalancerCommand = class _RegisterInstancesWithLoadBalancerCommand 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("ElasticLoadBalancing_v7", "RegisterInstancesWithLoadBalancer", {}).n("ElasticLoadBalancingClient", "RegisterInstancesWithLoadBalancerCommand").f(void 0, void 0).ser(se_RegisterInstancesWithLoadBalancerCommand).de(de_RegisterInstancesWithLoadBalancerCommand).build() {
+};
+__name(_RegisterInstancesWithLoadBalancerCommand, "RegisterInstancesWithLoadBalancerCommand");
+var RegisterInstancesWithLoadBalancerCommand = _RegisterInstancesWithLoadBalancerCommand;
+
+// src/commands/RemoveTagsCommand.ts
+
+
+
+
+var _RemoveTagsCommand = class _RemoveTagsCommand 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("ElasticLoadBalancing_v7", "RemoveTags", {}).n("ElasticLoadBalancingClient", "RemoveTagsCommand").f(void 0, void 0).ser(se_RemoveTagsCommand).de(de_RemoveTagsCommand).build() {
+};
+__name(_RemoveTagsCommand, "RemoveTagsCommand");
+var RemoveTagsCommand = _RemoveTagsCommand;
+
+// src/commands/SetLoadBalancerListenerSSLCertificateCommand.ts
+
+
+
+
+var _SetLoadBalancerListenerSSLCertificateCommand = class _SetLoadBalancerListenerSSLCertificateCommand 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("ElasticLoadBalancing_v7", "SetLoadBalancerListenerSSLCertificate", {}).n("ElasticLoadBalancingClient", "SetLoadBalancerListenerSSLCertificateCommand").f(void 0, void 0).ser(se_SetLoadBalancerListenerSSLCertificateCommand).de(de_SetLoadBalancerListenerSSLCertificateCommand).build() {
+};
+__name(_SetLoadBalancerListenerSSLCertificateCommand, "SetLoadBalancerListenerSSLCertificateCommand");
+var SetLoadBalancerListenerSSLCertificateCommand = _SetLoadBalancerListenerSSLCertificateCommand;
+
+// src/commands/SetLoadBalancerPoliciesForBackendServerCommand.ts
+
+
+
+
+var _SetLoadBalancerPoliciesForBackendServerCommand = class _SetLoadBalancerPoliciesForBackendServerCommand 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("ElasticLoadBalancing_v7", "SetLoadBalancerPoliciesForBackendServer", {}).n("ElasticLoadBalancingClient", "SetLoadBalancerPoliciesForBackendServerCommand").f(void 0, void 0).ser(se_SetLoadBalancerPoliciesForBackendServerCommand).de(de_SetLoadBalancerPoliciesForBackendServerCommand).build() {
+};
+__name(_SetLoadBalancerPoliciesForBackendServerCommand, "SetLoadBalancerPoliciesForBackendServerCommand");
+var SetLoadBalancerPoliciesForBackendServerCommand = _SetLoadBalancerPoliciesForBackendServerCommand;
+
+// src/commands/SetLoadBalancerPoliciesOfListenerCommand.ts
+
+
+
+
+var _SetLoadBalancerPoliciesOfListenerCommand = class _SetLoadBalancerPoliciesOfListenerCommand 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("ElasticLoadBalancing_v7", "SetLoadBalancerPoliciesOfListener", {}).n("ElasticLoadBalancingClient", "SetLoadBalancerPoliciesOfListenerCommand").f(void 0, void 0).ser(se_SetLoadBalancerPoliciesOfListenerCommand).de(de_SetLoadBalancerPoliciesOfListenerCommand).build() {
+};
+__name(_SetLoadBalancerPoliciesOfListenerCommand, "SetLoadBalancerPoliciesOfListenerCommand");
+var SetLoadBalancerPoliciesOfListenerCommand = _SetLoadBalancerPoliciesOfListenerCommand;
+
+// src/ElasticLoadBalancing.ts
+var commands = {
+  AddTagsCommand,
+  ApplySecurityGroupsToLoadBalancerCommand,
+  AttachLoadBalancerToSubnetsCommand,
+  ConfigureHealthCheckCommand,
+  CreateAppCookieStickinessPolicyCommand,
+  CreateLBCookieStickinessPolicyCommand,
+  CreateLoadBalancerCommand,
+  CreateLoadBalancerListenersCommand,
+  CreateLoadBalancerPolicyCommand,
+  DeleteLoadBalancerCommand,
+  DeleteLoadBalancerListenersCommand,
+  DeleteLoadBalancerPolicyCommand,
+  DeregisterInstancesFromLoadBalancerCommand,
+  DescribeAccountLimitsCommand,
+  DescribeInstanceHealthCommand,
+  DescribeLoadBalancerAttributesCommand,
+  DescribeLoadBalancerPoliciesCommand,
+  DescribeLoadBalancerPolicyTypesCommand,
+  DescribeLoadBalancersCommand,
+  DescribeTagsCommand,
+  DetachLoadBalancerFromSubnetsCommand,
+  DisableAvailabilityZonesForLoadBalancerCommand,
+  EnableAvailabilityZonesForLoadBalancerCommand,
+  ModifyLoadBalancerAttributesCommand,
+  RegisterInstancesWithLoadBalancerCommand,
+  RemoveTagsCommand,
+  SetLoadBalancerListenerSSLCertificateCommand,
+  SetLoadBalancerPoliciesForBackendServerCommand,
+  SetLoadBalancerPoliciesOfListenerCommand
+};
+var _ElasticLoadBalancing = class _ElasticLoadBalancing extends ElasticLoadBalancingClient {
+};
+__name(_ElasticLoadBalancing, "ElasticLoadBalancing");
+var ElasticLoadBalancing = _ElasticLoadBalancing;
+(0, import_smithy_client.createAggregatedClient)(commands, ElasticLoadBalancing);
+
+// src/pagination/DescribeLoadBalancersPaginator.ts
+var import_core = require("@smithy/core");
+var paginateDescribeLoadBalancers = (0, import_core.createPaginator)(ElasticLoadBalancingClient, DescribeLoadBalancersCommand, "Marker", "NextMarker", "");
+
+// src/waiters/waitForAnyInstanceInService.ts
+var import_util_waiter = require("@smithy/util-waiter");
+var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeInstanceHealthCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.InstanceStates);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.State;
+        });
+        return projection_3;
+      }, "returnComparator");
+      for (const anyStringEq_4 of returnComparator()) {
+        if (anyStringEq_4 == "InService") {
+          return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+        }
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForAnyInstanceInService = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForAnyInstanceInService");
+var waitUntilAnyInstanceInService = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilAnyInstanceInService");
+
+// src/waiters/waitForInstanceDeregistered.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeInstanceHealthCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.InstanceStates);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.State;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "OutOfService";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "InvalidInstance") {
+      return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForInstanceDeregistered = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "waitForInstanceDeregistered");
+var waitUntilInstanceDeregistered = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilInstanceDeregistered");
+
+// src/waiters/waitForInstanceInService.ts
+
+var checkState3 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new DescribeInstanceHealthCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        const flat_1 = [].concat(...result.InstanceStates);
+        const projection_3 = flat_1.map((element_2) => {
+          return element_2.State;
+        });
+        return projection_3;
+      }, "returnComparator");
+      let allStringEq_5 = returnComparator().length > 0;
+      for (const element_4 of returnComparator()) {
+        allStringEq_5 = allStringEq_5 && element_4 == "InService";
+      }
+      if (allStringEq_5) {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "InvalidInstance") {
+      return { state: import_util_waiter.WaiterState.RETRY, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForInstanceInService = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+}, "waitForInstanceInService");
+var waitUntilInstanceInService = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 15, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState3);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilInstanceInService");
+
+// 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 = {
+  AccessPointNotFoundException,
+  AddTagsCommand,
+  ApplySecurityGroupsToLoadBalancerCommand,
+  AttachLoadBalancerToSubnetsCommand,
+  CertificateNotFoundException,
+  ConfigureHealthCheckCommand,
+  CreateAppCookieStickinessPolicyCommand,
+  CreateLBCookieStickinessPolicyCommand,
+  CreateLoadBalancerCommand,
+  CreateLoadBalancerListenersCommand,
+  CreateLoadBalancerPolicyCommand,
+  DeleteLoadBalancerCommand,
+  DeleteLoadBalancerListenersCommand,
+  DeleteLoadBalancerPolicyCommand,
+  DependencyThrottleException,
+  DeregisterInstancesFromLoadBalancerCommand,
+  DescribeAccountLimitsCommand,
+  DescribeInstanceHealthCommand,
+  DescribeLoadBalancerAttributesCommand,
+  DescribeLoadBalancerPoliciesCommand,
+  DescribeLoadBalancerPolicyTypesCommand,
+  DescribeLoadBalancersCommand,
+  DescribeTagsCommand,
+  DetachLoadBalancerFromSubnetsCommand,
+  DisableAvailabilityZonesForLoadBalancerCommand,
+  DuplicateAccessPointNameException,
+  DuplicateListenerException,
+  DuplicatePolicyNameException,
+  DuplicateTagKeysException,
+  ElasticLoadBalancing,
+  ElasticLoadBalancingClient,
+  ElasticLoadBalancingServiceException,
+  EnableAvailabilityZonesForLoadBalancerCommand,
+  InvalidConfigurationRequestException,
+  InvalidEndPointException,
+  InvalidSchemeException,
+  InvalidSecurityGroupException,
+  InvalidSubnetException,
+  ListenerNotFoundException,
+  LoadBalancerAttributeNotFoundException,
+  ModifyLoadBalancerAttributesCommand,
+  OperationNotPermittedException,
+  PolicyNotFoundException,
+  PolicyTypeNotFoundException,
+  RegisterInstancesWithLoadBalancerCommand,
+  RemoveTagsCommand,
+  SetLoadBalancerListenerSSLCertificateCommand,
+  SetLoadBalancerPoliciesForBackendServerCommand,
+  SetLoadBalancerPoliciesOfListenerCommand,
+  SubnetNotFoundException,
+  TooManyAccessPointsException,
+  TooManyPoliciesException,
+  TooManyTagsException,
+  UnsupportedProtocolException,
+  __Client,
+  paginateDescribeLoadBalancers,
+  waitForAnyInstanceInService,
+  waitForInstanceDeregistered,
+  waitForInstanceInService,
+  waitUntilAnyInstanceInService,
+  waitUntilInstanceDeregistered,
+  waitUntilInstanceInService
+});