@aws-sdk/client-dax 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,11 +1,2646 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DAXServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./DAXClient"), exports);
-tslib_1.__exportStar(require("./DAX"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var DAXServiceException_1 = require("./models/DAXServiceException");
-Object.defineProperty(exports, "DAXServiceException", { enumerable: true, get: function () { return DAXServiceException_1.DAXServiceException; } });
+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, {
+  ChangeType: () => ChangeType,
+  ClusterAlreadyExistsFault: () => ClusterAlreadyExistsFault,
+  ClusterEndpointEncryptionType: () => ClusterEndpointEncryptionType,
+  ClusterNotFoundFault: () => ClusterNotFoundFault,
+  ClusterQuotaForCustomerExceededFault: () => ClusterQuotaForCustomerExceededFault,
+  CreateClusterCommand: () => CreateClusterCommand,
+  CreateParameterGroupCommand: () => CreateParameterGroupCommand,
+  CreateSubnetGroupCommand: () => CreateSubnetGroupCommand,
+  DAX: () => DAX,
+  DAXClient: () => DAXClient,
+  DAXServiceException: () => DAXServiceException,
+  DecreaseReplicationFactorCommand: () => DecreaseReplicationFactorCommand,
+  DeleteClusterCommand: () => DeleteClusterCommand,
+  DeleteParameterGroupCommand: () => DeleteParameterGroupCommand,
+  DeleteSubnetGroupCommand: () => DeleteSubnetGroupCommand,
+  DescribeClustersCommand: () => DescribeClustersCommand,
+  DescribeDefaultParametersCommand: () => DescribeDefaultParametersCommand,
+  DescribeEventsCommand: () => DescribeEventsCommand,
+  DescribeParameterGroupsCommand: () => DescribeParameterGroupsCommand,
+  DescribeParametersCommand: () => DescribeParametersCommand,
+  DescribeSubnetGroupsCommand: () => DescribeSubnetGroupsCommand,
+  IncreaseReplicationFactorCommand: () => IncreaseReplicationFactorCommand,
+  InsufficientClusterCapacityFault: () => InsufficientClusterCapacityFault,
+  InvalidARNFault: () => InvalidARNFault,
+  InvalidClusterStateFault: () => InvalidClusterStateFault,
+  InvalidParameterCombinationException: () => InvalidParameterCombinationException,
+  InvalidParameterGroupStateFault: () => InvalidParameterGroupStateFault,
+  InvalidParameterValueException: () => InvalidParameterValueException,
+  InvalidSubnet: () => InvalidSubnet,
+  InvalidVPCNetworkStateFault: () => InvalidVPCNetworkStateFault,
+  IsModifiable: () => IsModifiable,
+  ListTagsCommand: () => ListTagsCommand,
+  NodeNotFoundFault: () => NodeNotFoundFault,
+  NodeQuotaForClusterExceededFault: () => NodeQuotaForClusterExceededFault,
+  NodeQuotaForCustomerExceededFault: () => NodeQuotaForCustomerExceededFault,
+  ParameterGroupAlreadyExistsFault: () => ParameterGroupAlreadyExistsFault,
+  ParameterGroupNotFoundFault: () => ParameterGroupNotFoundFault,
+  ParameterGroupQuotaExceededFault: () => ParameterGroupQuotaExceededFault,
+  ParameterType: () => ParameterType,
+  RebootNodeCommand: () => RebootNodeCommand,
+  SSEStatus: () => SSEStatus,
+  ServiceLinkedRoleNotFoundFault: () => ServiceLinkedRoleNotFoundFault,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  SourceType: () => SourceType,
+  SubnetGroupAlreadyExistsFault: () => SubnetGroupAlreadyExistsFault,
+  SubnetGroupInUseFault: () => SubnetGroupInUseFault,
+  SubnetGroupNotFoundFault: () => SubnetGroupNotFoundFault,
+  SubnetGroupQuotaExceededFault: () => SubnetGroupQuotaExceededFault,
+  SubnetInUse: () => SubnetInUse,
+  SubnetQuotaExceededFault: () => SubnetQuotaExceededFault,
+  TagNotFoundFault: () => TagNotFoundFault,
+  TagQuotaPerResourceExceeded: () => TagQuotaPerResourceExceeded,
+  TagResourceCommand: () => TagResourceCommand,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateClusterCommand: () => UpdateClusterCommand,
+  UpdateParameterGroupCommand: () => UpdateParameterGroupCommand,
+  UpdateSubnetGroupCommand: () => UpdateSubnetGroupCommand,
+  __Client: () => import_smithy_client.Client
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/DAXClient.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: "dax"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/DAXClient.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/DAXClient.ts
+var _DAXClient = class _DAXClient 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(_DAXClient, "DAXClient");
+var DAXClient = _DAXClient;
+
+// src/DAX.ts
+
+
+// src/commands/CreateClusterCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/DAXServiceException.ts
+
+var _DAXServiceException = class _DAXServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _DAXServiceException.prototype);
+  }
+};
+__name(_DAXServiceException, "DAXServiceException");
+var DAXServiceException = _DAXServiceException;
+
+// src/models/models_0.ts
+var _ClusterAlreadyExistsFault = class _ClusterAlreadyExistsFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ClusterAlreadyExistsFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ClusterAlreadyExistsFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ClusterAlreadyExistsFault.prototype);
+  }
+};
+__name(_ClusterAlreadyExistsFault, "ClusterAlreadyExistsFault");
+var ClusterAlreadyExistsFault = _ClusterAlreadyExistsFault;
+var _ClusterQuotaForCustomerExceededFault = class _ClusterQuotaForCustomerExceededFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ClusterQuotaForCustomerExceededFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ClusterQuotaForCustomerExceededFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ClusterQuotaForCustomerExceededFault.prototype);
+  }
+};
+__name(_ClusterQuotaForCustomerExceededFault, "ClusterQuotaForCustomerExceededFault");
+var ClusterQuotaForCustomerExceededFault = _ClusterQuotaForCustomerExceededFault;
+var ClusterEndpointEncryptionType = {
+  NONE: "NONE",
+  TLS: "TLS"
+};
+var SSEStatus = {
+  DISABLED: "DISABLED",
+  DISABLING: "DISABLING",
+  ENABLED: "ENABLED",
+  ENABLING: "ENABLING"
+};
+var _InsufficientClusterCapacityFault = class _InsufficientClusterCapacityFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InsufficientClusterCapacityFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InsufficientClusterCapacityFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InsufficientClusterCapacityFault.prototype);
+  }
+};
+__name(_InsufficientClusterCapacityFault, "InsufficientClusterCapacityFault");
+var InsufficientClusterCapacityFault = _InsufficientClusterCapacityFault;
+var _InvalidClusterStateFault = class _InvalidClusterStateFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidClusterStateFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidClusterStateFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidClusterStateFault.prototype);
+  }
+};
+__name(_InvalidClusterStateFault, "InvalidClusterStateFault");
+var InvalidClusterStateFault = _InvalidClusterStateFault;
+var _InvalidParameterCombinationException = class _InvalidParameterCombinationException extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidParameterCombinationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidParameterCombinationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidParameterCombinationException.prototype);
+  }
+};
+__name(_InvalidParameterCombinationException, "InvalidParameterCombinationException");
+var InvalidParameterCombinationException = _InvalidParameterCombinationException;
+var _InvalidParameterGroupStateFault = class _InvalidParameterGroupStateFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidParameterGroupStateFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidParameterGroupStateFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidParameterGroupStateFault.prototype);
+  }
+};
+__name(_InvalidParameterGroupStateFault, "InvalidParameterGroupStateFault");
+var InvalidParameterGroupStateFault = _InvalidParameterGroupStateFault;
+var _InvalidParameterValueException = class _InvalidParameterValueException extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidParameterValueException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidParameterValueException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidParameterValueException.prototype);
+  }
+};
+__name(_InvalidParameterValueException, "InvalidParameterValueException");
+var InvalidParameterValueException = _InvalidParameterValueException;
+var _InvalidVPCNetworkStateFault = class _InvalidVPCNetworkStateFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidVPCNetworkStateFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidVPCNetworkStateFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidVPCNetworkStateFault.prototype);
+  }
+};
+__name(_InvalidVPCNetworkStateFault, "InvalidVPCNetworkStateFault");
+var InvalidVPCNetworkStateFault = _InvalidVPCNetworkStateFault;
+var _NodeQuotaForClusterExceededFault = class _NodeQuotaForClusterExceededFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NodeQuotaForClusterExceededFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NodeQuotaForClusterExceededFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NodeQuotaForClusterExceededFault.prototype);
+  }
+};
+__name(_NodeQuotaForClusterExceededFault, "NodeQuotaForClusterExceededFault");
+var NodeQuotaForClusterExceededFault = _NodeQuotaForClusterExceededFault;
+var _NodeQuotaForCustomerExceededFault = class _NodeQuotaForCustomerExceededFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NodeQuotaForCustomerExceededFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NodeQuotaForCustomerExceededFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NodeQuotaForCustomerExceededFault.prototype);
+  }
+};
+__name(_NodeQuotaForCustomerExceededFault, "NodeQuotaForCustomerExceededFault");
+var NodeQuotaForCustomerExceededFault = _NodeQuotaForCustomerExceededFault;
+var _ParameterGroupNotFoundFault = class _ParameterGroupNotFoundFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ParameterGroupNotFoundFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ParameterGroupNotFoundFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ParameterGroupNotFoundFault.prototype);
+  }
+};
+__name(_ParameterGroupNotFoundFault, "ParameterGroupNotFoundFault");
+var ParameterGroupNotFoundFault = _ParameterGroupNotFoundFault;
+var _ServiceLinkedRoleNotFoundFault = class _ServiceLinkedRoleNotFoundFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceLinkedRoleNotFoundFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceLinkedRoleNotFoundFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceLinkedRoleNotFoundFault.prototype);
+  }
+};
+__name(_ServiceLinkedRoleNotFoundFault, "ServiceLinkedRoleNotFoundFault");
+var ServiceLinkedRoleNotFoundFault = _ServiceLinkedRoleNotFoundFault;
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var _SubnetGroupNotFoundFault = class _SubnetGroupNotFoundFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SubnetGroupNotFoundFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SubnetGroupNotFoundFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SubnetGroupNotFoundFault.prototype);
+  }
+};
+__name(_SubnetGroupNotFoundFault, "SubnetGroupNotFoundFault");
+var SubnetGroupNotFoundFault = _SubnetGroupNotFoundFault;
+var _TagQuotaPerResourceExceeded = class _TagQuotaPerResourceExceeded extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TagQuotaPerResourceExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TagQuotaPerResourceExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TagQuotaPerResourceExceeded.prototype);
+  }
+};
+__name(_TagQuotaPerResourceExceeded, "TagQuotaPerResourceExceeded");
+var TagQuotaPerResourceExceeded = _TagQuotaPerResourceExceeded;
+var _ParameterGroupAlreadyExistsFault = class _ParameterGroupAlreadyExistsFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ParameterGroupAlreadyExistsFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ParameterGroupAlreadyExistsFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ParameterGroupAlreadyExistsFault.prototype);
+  }
+};
+__name(_ParameterGroupAlreadyExistsFault, "ParameterGroupAlreadyExistsFault");
+var ParameterGroupAlreadyExistsFault = _ParameterGroupAlreadyExistsFault;
+var _ParameterGroupQuotaExceededFault = class _ParameterGroupQuotaExceededFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ParameterGroupQuotaExceededFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ParameterGroupQuotaExceededFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ParameterGroupQuotaExceededFault.prototype);
+  }
+};
+__name(_ParameterGroupQuotaExceededFault, "ParameterGroupQuotaExceededFault");
+var ParameterGroupQuotaExceededFault = _ParameterGroupQuotaExceededFault;
+var _InvalidSubnet = class _InvalidSubnet extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidSubnet",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidSubnet";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidSubnet.prototype);
+  }
+};
+__name(_InvalidSubnet, "InvalidSubnet");
+var InvalidSubnet = _InvalidSubnet;
+var _SubnetGroupAlreadyExistsFault = class _SubnetGroupAlreadyExistsFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SubnetGroupAlreadyExistsFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SubnetGroupAlreadyExistsFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SubnetGroupAlreadyExistsFault.prototype);
+  }
+};
+__name(_SubnetGroupAlreadyExistsFault, "SubnetGroupAlreadyExistsFault");
+var SubnetGroupAlreadyExistsFault = _SubnetGroupAlreadyExistsFault;
+var _SubnetGroupQuotaExceededFault = class _SubnetGroupQuotaExceededFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SubnetGroupQuotaExceededFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SubnetGroupQuotaExceededFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SubnetGroupQuotaExceededFault.prototype);
+  }
+};
+__name(_SubnetGroupQuotaExceededFault, "SubnetGroupQuotaExceededFault");
+var SubnetGroupQuotaExceededFault = _SubnetGroupQuotaExceededFault;
+var _SubnetQuotaExceededFault = class _SubnetQuotaExceededFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SubnetQuotaExceededFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SubnetQuotaExceededFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SubnetQuotaExceededFault.prototype);
+  }
+};
+__name(_SubnetQuotaExceededFault, "SubnetQuotaExceededFault");
+var SubnetQuotaExceededFault = _SubnetQuotaExceededFault;
+var _ClusterNotFoundFault = class _ClusterNotFoundFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ClusterNotFoundFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ClusterNotFoundFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ClusterNotFoundFault.prototype);
+  }
+};
+__name(_ClusterNotFoundFault, "ClusterNotFoundFault");
+var ClusterNotFoundFault = _ClusterNotFoundFault;
+var _NodeNotFoundFault = class _NodeNotFoundFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "NodeNotFoundFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "NodeNotFoundFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _NodeNotFoundFault.prototype);
+  }
+};
+__name(_NodeNotFoundFault, "NodeNotFoundFault");
+var NodeNotFoundFault = _NodeNotFoundFault;
+var _SubnetGroupInUseFault = class _SubnetGroupInUseFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SubnetGroupInUseFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SubnetGroupInUseFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SubnetGroupInUseFault.prototype);
+  }
+};
+__name(_SubnetGroupInUseFault, "SubnetGroupInUseFault");
+var SubnetGroupInUseFault = _SubnetGroupInUseFault;
+var ChangeType = {
+  IMMEDIATE: "IMMEDIATE",
+  REQUIRES_REBOOT: "REQUIRES_REBOOT"
+};
+var IsModifiable = {
+  CONDITIONAL: "CONDITIONAL",
+  FALSE: "FALSE",
+  TRUE: "TRUE"
+};
+var ParameterType = {
+  DEFAULT: "DEFAULT",
+  NODE_TYPE_SPECIFIC: "NODE_TYPE_SPECIFIC"
+};
+var SourceType = {
+  CLUSTER: "CLUSTER",
+  PARAMETER_GROUP: "PARAMETER_GROUP",
+  SUBNET_GROUP: "SUBNET_GROUP"
+};
+var _InvalidARNFault = class _InvalidARNFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidARNFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidARNFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidARNFault.prototype);
+  }
+};
+__name(_InvalidARNFault, "InvalidARNFault");
+var InvalidARNFault = _InvalidARNFault;
+var _TagNotFoundFault = class _TagNotFoundFault extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "TagNotFoundFault",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "TagNotFoundFault";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _TagNotFoundFault.prototype);
+  }
+};
+__name(_TagNotFoundFault, "TagNotFoundFault");
+var TagNotFoundFault = _TagNotFoundFault;
+var _SubnetInUse = class _SubnetInUse extends DAXServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "SubnetInUse",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "SubnetInUse";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _SubnetInUse.prototype);
+  }
+};
+__name(_SubnetInUse, "SubnetInUse");
+var SubnetInUse = _SubnetInUse;
+
+// src/protocols/Aws_json1_1.ts
+var se_CreateClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateCluster");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateClusterCommand");
+var se_CreateParameterGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateParameterGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateParameterGroupCommand");
+var se_CreateSubnetGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateSubnetGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateSubnetGroupCommand");
+var se_DecreaseReplicationFactorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DecreaseReplicationFactor");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DecreaseReplicationFactorCommand");
+var se_DeleteClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteCluster");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteClusterCommand");
+var se_DeleteParameterGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteParameterGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteParameterGroupCommand");
+var se_DeleteSubnetGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DeleteSubnetGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DeleteSubnetGroupCommand");
+var se_DescribeClustersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeClusters");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeClustersCommand");
+var se_DescribeDefaultParametersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeDefaultParameters");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeDefaultParametersCommand");
+var se_DescribeEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeEvents");
+  let body;
+  body = JSON.stringify(se_DescribeEventsRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeEventsCommand");
+var se_DescribeParameterGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeParameterGroups");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeParameterGroupsCommand");
+var se_DescribeParametersCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeParameters");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeParametersCommand");
+var se_DescribeSubnetGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeSubnetGroups");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeSubnetGroupsCommand");
+var se_IncreaseReplicationFactorCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("IncreaseReplicationFactor");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_IncreaseReplicationFactorCommand");
+var se_ListTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ListTags");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ListTagsCommand");
+var se_RebootNodeCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RebootNode");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RebootNodeCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("TagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UntagResource");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UntagResourceCommand");
+var se_UpdateClusterCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateCluster");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateClusterCommand");
+var se_UpdateParameterGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateParameterGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateParameterGroupCommand");
+var se_UpdateSubnetGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("UpdateSubnetGroup");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_UpdateSubnetGroupCommand");
+var de_CreateClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateClusterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_CreateClusterResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateClusterCommand");
+var de_CreateClusterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClusterAlreadyExistsFault":
+    case "com.amazonaws.dax#ClusterAlreadyExistsFault":
+      throw await de_ClusterAlreadyExistsFaultRes(parsedOutput, context);
+    case "ClusterQuotaForCustomerExceededFault":
+    case "com.amazonaws.dax#ClusterQuotaForCustomerExceededFault":
+      throw await de_ClusterQuotaForCustomerExceededFaultRes(parsedOutput, context);
+    case "InsufficientClusterCapacityFault":
+    case "com.amazonaws.dax#InsufficientClusterCapacityFault":
+      throw await de_InsufficientClusterCapacityFaultRes(parsedOutput, context);
+    case "InvalidClusterStateFault":
+    case "com.amazonaws.dax#InvalidClusterStateFault":
+      throw await de_InvalidClusterStateFaultRes(parsedOutput, context);
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterGroupStateFault":
+    case "com.amazonaws.dax#InvalidParameterGroupStateFault":
+      throw await de_InvalidParameterGroupStateFaultRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "InvalidVPCNetworkStateFault":
+    case "com.amazonaws.dax#InvalidVPCNetworkStateFault":
+      throw await de_InvalidVPCNetworkStateFaultRes(parsedOutput, context);
+    case "NodeQuotaForClusterExceededFault":
+    case "com.amazonaws.dax#NodeQuotaForClusterExceededFault":
+      throw await de_NodeQuotaForClusterExceededFaultRes(parsedOutput, context);
+    case "NodeQuotaForCustomerExceededFault":
+    case "com.amazonaws.dax#NodeQuotaForCustomerExceededFault":
+      throw await de_NodeQuotaForCustomerExceededFaultRes(parsedOutput, context);
+    case "ParameterGroupNotFoundFault":
+    case "com.amazonaws.dax#ParameterGroupNotFoundFault":
+      throw await de_ParameterGroupNotFoundFaultRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.dax#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "SubnetGroupNotFoundFault":
+    case "com.amazonaws.dax#SubnetGroupNotFoundFault":
+      throw await de_SubnetGroupNotFoundFaultRes(parsedOutput, context);
+    case "TagQuotaPerResourceExceeded":
+    case "com.amazonaws.dax#TagQuotaPerResourceExceeded":
+      throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateClusterCommandError");
+var de_CreateParameterGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateParameterGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateParameterGroupCommand");
+var de_CreateParameterGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterGroupStateFault":
+    case "com.amazonaws.dax#InvalidParameterGroupStateFault":
+      throw await de_InvalidParameterGroupStateFaultRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ParameterGroupAlreadyExistsFault":
+    case "com.amazonaws.dax#ParameterGroupAlreadyExistsFault":
+      throw await de_ParameterGroupAlreadyExistsFaultRes(parsedOutput, context);
+    case "ParameterGroupQuotaExceededFault":
+    case "com.amazonaws.dax#ParameterGroupQuotaExceededFault":
+      throw await de_ParameterGroupQuotaExceededFaultRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateParameterGroupCommandError");
+var de_CreateSubnetGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateSubnetGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateSubnetGroupCommand");
+var de_CreateSubnetGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidSubnet":
+    case "com.amazonaws.dax#InvalidSubnet":
+      throw await de_InvalidSubnetRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    case "SubnetGroupAlreadyExistsFault":
+    case "com.amazonaws.dax#SubnetGroupAlreadyExistsFault":
+      throw await de_SubnetGroupAlreadyExistsFaultRes(parsedOutput, context);
+    case "SubnetGroupQuotaExceededFault":
+    case "com.amazonaws.dax#SubnetGroupQuotaExceededFault":
+      throw await de_SubnetGroupQuotaExceededFaultRes(parsedOutput, context);
+    case "SubnetQuotaExceededFault":
+    case "com.amazonaws.dax#SubnetQuotaExceededFault":
+      throw await de_SubnetQuotaExceededFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateSubnetGroupCommandError");
+var de_DecreaseReplicationFactorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DecreaseReplicationFactorCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DecreaseReplicationFactorResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DecreaseReplicationFactorCommand");
+var de_DecreaseReplicationFactorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClusterNotFoundFault":
+    case "com.amazonaws.dax#ClusterNotFoundFault":
+      throw await de_ClusterNotFoundFaultRes(parsedOutput, context);
+    case "InvalidClusterStateFault":
+    case "com.amazonaws.dax#InvalidClusterStateFault":
+      throw await de_InvalidClusterStateFaultRes(parsedOutput, context);
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "NodeNotFoundFault":
+    case "com.amazonaws.dax#NodeNotFoundFault":
+      throw await de_NodeNotFoundFaultRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DecreaseReplicationFactorCommandError");
+var de_DeleteClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteClusterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DeleteClusterResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteClusterCommand");
+var de_DeleteClusterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClusterNotFoundFault":
+    case "com.amazonaws.dax#ClusterNotFoundFault":
+      throw await de_ClusterNotFoundFaultRes(parsedOutput, context);
+    case "InvalidClusterStateFault":
+    case "com.amazonaws.dax#InvalidClusterStateFault":
+      throw await de_InvalidClusterStateFaultRes(parsedOutput, context);
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteClusterCommandError");
+var de_DeleteParameterGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteParameterGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteParameterGroupCommand");
+var de_DeleteParameterGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterGroupStateFault":
+    case "com.amazonaws.dax#InvalidParameterGroupStateFault":
+      throw await de_InvalidParameterGroupStateFaultRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ParameterGroupNotFoundFault":
+    case "com.amazonaws.dax#ParameterGroupNotFoundFault":
+      throw await de_ParameterGroupNotFoundFaultRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteParameterGroupCommandError");
+var de_DeleteSubnetGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DeleteSubnetGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DeleteSubnetGroupCommand");
+var de_DeleteSubnetGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    case "SubnetGroupInUseFault":
+    case "com.amazonaws.dax#SubnetGroupInUseFault":
+      throw await de_SubnetGroupInUseFaultRes(parsedOutput, context);
+    case "SubnetGroupNotFoundFault":
+    case "com.amazonaws.dax#SubnetGroupNotFoundFault":
+      throw await de_SubnetGroupNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteSubnetGroupCommandError");
+var de_DescribeClustersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeClustersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeClustersResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeClustersCommand");
+var de_DescribeClustersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClusterNotFoundFault":
+    case "com.amazonaws.dax#ClusterNotFoundFault":
+      throw await de_ClusterNotFoundFaultRes(parsedOutput, context);
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeClustersCommandError");
+var de_DescribeDefaultParametersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeDefaultParametersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeDefaultParametersCommand");
+var de_DescribeDefaultParametersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeDefaultParametersCommandError");
+var de_DescribeEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEventsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeEventsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeEventsCommand");
+var de_DescribeEventsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeEventsCommandError");
+var de_DescribeParameterGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeParameterGroupsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeParameterGroupsCommand");
+var de_DescribeParameterGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ParameterGroupNotFoundFault":
+    case "com.amazonaws.dax#ParameterGroupNotFoundFault":
+      throw await de_ParameterGroupNotFoundFaultRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeParameterGroupsCommandError");
+var de_DescribeParametersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeParametersCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeParametersCommand");
+var de_DescribeParametersCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ParameterGroupNotFoundFault":
+    case "com.amazonaws.dax#ParameterGroupNotFoundFault":
+      throw await de_ParameterGroupNotFoundFaultRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeParametersCommandError");
+var de_DescribeSubnetGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeSubnetGroupsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeSubnetGroupsCommand");
+var de_DescribeSubnetGroupsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    case "SubnetGroupNotFoundFault":
+    case "com.amazonaws.dax#SubnetGroupNotFoundFault":
+      throw await de_SubnetGroupNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeSubnetGroupsCommandError");
+var de_IncreaseReplicationFactorCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_IncreaseReplicationFactorCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_IncreaseReplicationFactorResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_IncreaseReplicationFactorCommand");
+var de_IncreaseReplicationFactorCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClusterNotFoundFault":
+    case "com.amazonaws.dax#ClusterNotFoundFault":
+      throw await de_ClusterNotFoundFaultRes(parsedOutput, context);
+    case "InsufficientClusterCapacityFault":
+    case "com.amazonaws.dax#InsufficientClusterCapacityFault":
+      throw await de_InsufficientClusterCapacityFaultRes(parsedOutput, context);
+    case "InvalidClusterStateFault":
+    case "com.amazonaws.dax#InvalidClusterStateFault":
+      throw await de_InvalidClusterStateFaultRes(parsedOutput, context);
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "InvalidVPCNetworkStateFault":
+    case "com.amazonaws.dax#InvalidVPCNetworkStateFault":
+      throw await de_InvalidVPCNetworkStateFaultRes(parsedOutput, context);
+    case "NodeQuotaForClusterExceededFault":
+    case "com.amazonaws.dax#NodeQuotaForClusterExceededFault":
+      throw await de_NodeQuotaForClusterExceededFaultRes(parsedOutput, context);
+    case "NodeQuotaForCustomerExceededFault":
+    case "com.amazonaws.dax#NodeQuotaForCustomerExceededFault":
+      throw await de_NodeQuotaForCustomerExceededFaultRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_IncreaseReplicationFactorCommandError");
+var de_ListTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ListTagsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ListTagsCommand");
+var de_ListTagsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClusterNotFoundFault":
+    case "com.amazonaws.dax#ClusterNotFoundFault":
+      throw await de_ClusterNotFoundFaultRes(parsedOutput, context);
+    case "InvalidARNFault":
+    case "com.amazonaws.dax#InvalidARNFault":
+      throw await de_InvalidARNFaultRes(parsedOutput, context);
+    case "InvalidClusterStateFault":
+    case "com.amazonaws.dax#InvalidClusterStateFault":
+      throw await de_InvalidClusterStateFaultRes(parsedOutput, context);
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsCommandError");
+var de_RebootNodeCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RebootNodeCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_RebootNodeResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RebootNodeCommand");
+var de_RebootNodeCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClusterNotFoundFault":
+    case "com.amazonaws.dax#ClusterNotFoundFault":
+      throw await de_ClusterNotFoundFaultRes(parsedOutput, context);
+    case "InvalidClusterStateFault":
+    case "com.amazonaws.dax#InvalidClusterStateFault":
+      throw await de_InvalidClusterStateFaultRes(parsedOutput, context);
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "NodeNotFoundFault":
+    case "com.amazonaws.dax#NodeNotFoundFault":
+      throw await de_NodeNotFoundFaultRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RebootNodeCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClusterNotFoundFault":
+    case "com.amazonaws.dax#ClusterNotFoundFault":
+      throw await de_ClusterNotFoundFaultRes(parsedOutput, context);
+    case "InvalidARNFault":
+    case "com.amazonaws.dax#InvalidARNFault":
+      throw await de_InvalidARNFaultRes(parsedOutput, context);
+    case "InvalidClusterStateFault":
+    case "com.amazonaws.dax#InvalidClusterStateFault":
+      throw await de_InvalidClusterStateFaultRes(parsedOutput, context);
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    case "TagQuotaPerResourceExceeded":
+    case "com.amazonaws.dax#TagQuotaPerResourceExceeded":
+      throw await de_TagQuotaPerResourceExceededRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClusterNotFoundFault":
+    case "com.amazonaws.dax#ClusterNotFoundFault":
+      throw await de_ClusterNotFoundFaultRes(parsedOutput, context);
+    case "InvalidARNFault":
+    case "com.amazonaws.dax#InvalidARNFault":
+      throw await de_InvalidARNFaultRes(parsedOutput, context);
+    case "InvalidClusterStateFault":
+    case "com.amazonaws.dax#InvalidClusterStateFault":
+      throw await de_InvalidClusterStateFaultRes(parsedOutput, context);
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    case "TagNotFoundFault":
+    case "com.amazonaws.dax#TagNotFoundFault":
+      throw await de_TagNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateClusterCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_UpdateClusterResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateClusterCommand");
+var de_UpdateClusterCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ClusterNotFoundFault":
+    case "com.amazonaws.dax#ClusterNotFoundFault":
+      throw await de_ClusterNotFoundFaultRes(parsedOutput, context);
+    case "InvalidClusterStateFault":
+    case "com.amazonaws.dax#InvalidClusterStateFault":
+      throw await de_InvalidClusterStateFaultRes(parsedOutput, context);
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterGroupStateFault":
+    case "com.amazonaws.dax#InvalidParameterGroupStateFault":
+      throw await de_InvalidParameterGroupStateFaultRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ParameterGroupNotFoundFault":
+    case "com.amazonaws.dax#ParameterGroupNotFoundFault":
+      throw await de_ParameterGroupNotFoundFaultRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateClusterCommandError");
+var de_UpdateParameterGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateParameterGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateParameterGroupCommand");
+var de_UpdateParameterGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidParameterCombinationException":
+    case "com.amazonaws.dax#InvalidParameterCombinationException":
+      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
+    case "InvalidParameterGroupStateFault":
+    case "com.amazonaws.dax#InvalidParameterGroupStateFault":
+      throw await de_InvalidParameterGroupStateFaultRes(parsedOutput, context);
+    case "InvalidParameterValueException":
+    case "com.amazonaws.dax#InvalidParameterValueException":
+      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
+    case "ParameterGroupNotFoundFault":
+    case "com.amazonaws.dax#ParameterGroupNotFoundFault":
+      throw await de_ParameterGroupNotFoundFaultRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateParameterGroupCommandError");
+var de_UpdateSubnetGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_UpdateSubnetGroupCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_UpdateSubnetGroupCommand");
+var de_UpdateSubnetGroupCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidSubnet":
+    case "com.amazonaws.dax#InvalidSubnet":
+      throw await de_InvalidSubnetRes(parsedOutput, context);
+    case "ServiceLinkedRoleNotFoundFault":
+    case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+      throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput, context);
+    case "SubnetGroupNotFoundFault":
+    case "com.amazonaws.dax#SubnetGroupNotFoundFault":
+      throw await de_SubnetGroupNotFoundFaultRes(parsedOutput, context);
+    case "SubnetInUse":
+    case "com.amazonaws.dax#SubnetInUse":
+      throw await de_SubnetInUseRes(parsedOutput, context);
+    case "SubnetQuotaExceededFault":
+    case "com.amazonaws.dax#SubnetQuotaExceededFault":
+      throw await de_SubnetQuotaExceededFaultRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateSubnetGroupCommandError");
+var de_ClusterAlreadyExistsFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ClusterAlreadyExistsFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ClusterAlreadyExistsFaultRes");
+var de_ClusterNotFoundFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ClusterNotFoundFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ClusterNotFoundFaultRes");
+var de_ClusterQuotaForCustomerExceededFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ClusterQuotaForCustomerExceededFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ClusterQuotaForCustomerExceededFaultRes");
+var de_InsufficientClusterCapacityFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InsufficientClusterCapacityFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InsufficientClusterCapacityFaultRes");
+var de_InvalidARNFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidARNFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidARNFaultRes");
+var de_InvalidClusterStateFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidClusterStateFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidClusterStateFaultRes");
+var de_InvalidParameterCombinationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidParameterCombinationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidParameterCombinationExceptionRes");
+var de_InvalidParameterGroupStateFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidParameterGroupStateFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidParameterGroupStateFaultRes");
+var de_InvalidParameterValueExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidParameterValueException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidParameterValueExceptionRes");
+var de_InvalidSubnetRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidSubnet({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidSubnetRes");
+var de_InvalidVPCNetworkStateFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidVPCNetworkStateFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidVPCNetworkStateFaultRes");
+var de_NodeNotFoundFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new NodeNotFoundFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_NodeNotFoundFaultRes");
+var de_NodeQuotaForClusterExceededFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new NodeQuotaForClusterExceededFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_NodeQuotaForClusterExceededFaultRes");
+var de_NodeQuotaForCustomerExceededFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new NodeQuotaForCustomerExceededFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_NodeQuotaForCustomerExceededFaultRes");
+var de_ParameterGroupAlreadyExistsFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ParameterGroupAlreadyExistsFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ParameterGroupAlreadyExistsFaultRes");
+var de_ParameterGroupNotFoundFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ParameterGroupNotFoundFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ParameterGroupNotFoundFaultRes");
+var de_ParameterGroupQuotaExceededFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ParameterGroupQuotaExceededFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ParameterGroupQuotaExceededFaultRes");
+var de_ServiceLinkedRoleNotFoundFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceLinkedRoleNotFoundFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceLinkedRoleNotFoundFaultRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_SubnetGroupAlreadyExistsFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new SubnetGroupAlreadyExistsFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_SubnetGroupAlreadyExistsFaultRes");
+var de_SubnetGroupInUseFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new SubnetGroupInUseFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_SubnetGroupInUseFaultRes");
+var de_SubnetGroupNotFoundFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new SubnetGroupNotFoundFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_SubnetGroupNotFoundFaultRes");
+var de_SubnetGroupQuotaExceededFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new SubnetGroupQuotaExceededFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_SubnetGroupQuotaExceededFaultRes");
+var de_SubnetInUseRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new SubnetInUse({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_SubnetInUseRes");
+var de_SubnetQuotaExceededFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new SubnetQuotaExceededFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_SubnetQuotaExceededFaultRes");
+var de_TagNotFoundFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TagNotFoundFault({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TagNotFoundFaultRes");
+var de_TagQuotaPerResourceExceededRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new TagQuotaPerResourceExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_TagQuotaPerResourceExceededRes");
+var se_DescribeEventsRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    Duration: [],
+    EndTime: (_) => Math.round(_.getTime() / 1e3),
+    MaxResults: [],
+    NextToken: [],
+    SourceName: [],
+    SourceType: [],
+    StartTime: (_) => Math.round(_.getTime() / 1e3)
+  });
+}, "se_DescribeEventsRequest");
+var de_Cluster = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    ActiveNodes: import_smithy_client.expectInt32,
+    ClusterArn: import_smithy_client.expectString,
+    ClusterDiscoveryEndpoint: import_smithy_client._json,
+    ClusterEndpointEncryptionType: import_smithy_client.expectString,
+    ClusterName: import_smithy_client.expectString,
+    Description: import_smithy_client.expectString,
+    IamRoleArn: import_smithy_client.expectString,
+    NodeIdsToRemove: import_smithy_client._json,
+    NodeType: import_smithy_client.expectString,
+    Nodes: (_) => de_NodeList(_, context),
+    NotificationConfiguration: import_smithy_client._json,
+    ParameterGroup: import_smithy_client._json,
+    PreferredMaintenanceWindow: import_smithy_client.expectString,
+    SSEDescription: import_smithy_client._json,
+    SecurityGroups: import_smithy_client._json,
+    Status: import_smithy_client.expectString,
+    SubnetGroup: import_smithy_client.expectString,
+    TotalNodes: import_smithy_client.expectInt32
+  });
+}, "de_Cluster");
+var de_ClusterList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Cluster(entry, context);
+  });
+  return retVal;
+}, "de_ClusterList");
+var de_CreateClusterResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Cluster: (_) => de_Cluster(_, context)
+  });
+}, "de_CreateClusterResponse");
+var de_DecreaseReplicationFactorResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Cluster: (_) => de_Cluster(_, context)
+  });
+}, "de_DecreaseReplicationFactorResponse");
+var de_DeleteClusterResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Cluster: (_) => de_Cluster(_, context)
+  });
+}, "de_DeleteClusterResponse");
+var de_DescribeClustersResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Clusters: (_) => de_ClusterList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_DescribeClustersResponse");
+var de_DescribeEventsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Events: (_) => de_EventList(_, context),
+    NextToken: import_smithy_client.expectString
+  });
+}, "de_DescribeEventsResponse");
+var de_Event = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Date: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    Message: import_smithy_client.expectString,
+    SourceName: import_smithy_client.expectString,
+    SourceType: import_smithy_client.expectString
+  });
+}, "de_Event");
+var de_EventList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Event(entry, context);
+  });
+  return retVal;
+}, "de_EventList");
+var de_IncreaseReplicationFactorResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Cluster: (_) => de_Cluster(_, context)
+  });
+}, "de_IncreaseReplicationFactorResponse");
+var de_Node = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    AvailabilityZone: import_smithy_client.expectString,
+    Endpoint: import_smithy_client._json,
+    NodeCreateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    NodeId: import_smithy_client.expectString,
+    NodeStatus: import_smithy_client.expectString,
+    ParameterGroupStatus: import_smithy_client.expectString
+  });
+}, "de_Node");
+var de_NodeList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Node(entry, context);
+  });
+  return retVal;
+}, "de_NodeList");
+var de_RebootNodeResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Cluster: (_) => de_Cluster(_, context)
+  });
+}, "de_RebootNodeResponse");
+var de_UpdateClusterResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Cluster: (_) => de_Cluster(_, context)
+  });
+}, "de_UpdateClusterResponse");
+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)(DAXServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `AmazonDAXV3.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/CreateClusterCommand.ts
+var _CreateClusterCommand = class _CreateClusterCommand 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("AmazonDAXV3", "CreateCluster", {}).n("DAXClient", "CreateClusterCommand").f(void 0, void 0).ser(se_CreateClusterCommand).de(de_CreateClusterCommand).build() {
+};
+__name(_CreateClusterCommand, "CreateClusterCommand");
+var CreateClusterCommand = _CreateClusterCommand;
+
+// src/commands/CreateParameterGroupCommand.ts
+
+
+
+
+var _CreateParameterGroupCommand = class _CreateParameterGroupCommand 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("AmazonDAXV3", "CreateParameterGroup", {}).n("DAXClient", "CreateParameterGroupCommand").f(void 0, void 0).ser(se_CreateParameterGroupCommand).de(de_CreateParameterGroupCommand).build() {
+};
+__name(_CreateParameterGroupCommand, "CreateParameterGroupCommand");
+var CreateParameterGroupCommand = _CreateParameterGroupCommand;
+
+// src/commands/CreateSubnetGroupCommand.ts
+
+
+
+
+var _CreateSubnetGroupCommand = class _CreateSubnetGroupCommand 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("AmazonDAXV3", "CreateSubnetGroup", {}).n("DAXClient", "CreateSubnetGroupCommand").f(void 0, void 0).ser(se_CreateSubnetGroupCommand).de(de_CreateSubnetGroupCommand).build() {
+};
+__name(_CreateSubnetGroupCommand, "CreateSubnetGroupCommand");
+var CreateSubnetGroupCommand = _CreateSubnetGroupCommand;
+
+// src/commands/DecreaseReplicationFactorCommand.ts
+
+
+
+
+var _DecreaseReplicationFactorCommand = class _DecreaseReplicationFactorCommand 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("AmazonDAXV3", "DecreaseReplicationFactor", {}).n("DAXClient", "DecreaseReplicationFactorCommand").f(void 0, void 0).ser(se_DecreaseReplicationFactorCommand).de(de_DecreaseReplicationFactorCommand).build() {
+};
+__name(_DecreaseReplicationFactorCommand, "DecreaseReplicationFactorCommand");
+var DecreaseReplicationFactorCommand = _DecreaseReplicationFactorCommand;
+
+// src/commands/DeleteClusterCommand.ts
+
+
+
+
+var _DeleteClusterCommand = class _DeleteClusterCommand 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("AmazonDAXV3", "DeleteCluster", {}).n("DAXClient", "DeleteClusterCommand").f(void 0, void 0).ser(se_DeleteClusterCommand).de(de_DeleteClusterCommand).build() {
+};
+__name(_DeleteClusterCommand, "DeleteClusterCommand");
+var DeleteClusterCommand = _DeleteClusterCommand;
+
+// src/commands/DeleteParameterGroupCommand.ts
+
+
+
+
+var _DeleteParameterGroupCommand = class _DeleteParameterGroupCommand 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("AmazonDAXV3", "DeleteParameterGroup", {}).n("DAXClient", "DeleteParameterGroupCommand").f(void 0, void 0).ser(se_DeleteParameterGroupCommand).de(de_DeleteParameterGroupCommand).build() {
+};
+__name(_DeleteParameterGroupCommand, "DeleteParameterGroupCommand");
+var DeleteParameterGroupCommand = _DeleteParameterGroupCommand;
+
+// src/commands/DeleteSubnetGroupCommand.ts
+
+
+
+
+var _DeleteSubnetGroupCommand = class _DeleteSubnetGroupCommand 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("AmazonDAXV3", "DeleteSubnetGroup", {}).n("DAXClient", "DeleteSubnetGroupCommand").f(void 0, void 0).ser(se_DeleteSubnetGroupCommand).de(de_DeleteSubnetGroupCommand).build() {
+};
+__name(_DeleteSubnetGroupCommand, "DeleteSubnetGroupCommand");
+var DeleteSubnetGroupCommand = _DeleteSubnetGroupCommand;
+
+// src/commands/DescribeClustersCommand.ts
+
+
+
+
+var _DescribeClustersCommand = class _DescribeClustersCommand 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("AmazonDAXV3", "DescribeClusters", {}).n("DAXClient", "DescribeClustersCommand").f(void 0, void 0).ser(se_DescribeClustersCommand).de(de_DescribeClustersCommand).build() {
+};
+__name(_DescribeClustersCommand, "DescribeClustersCommand");
+var DescribeClustersCommand = _DescribeClustersCommand;
+
+// src/commands/DescribeDefaultParametersCommand.ts
+
+
+
+
+var _DescribeDefaultParametersCommand = class _DescribeDefaultParametersCommand 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("AmazonDAXV3", "DescribeDefaultParameters", {}).n("DAXClient", "DescribeDefaultParametersCommand").f(void 0, void 0).ser(se_DescribeDefaultParametersCommand).de(de_DescribeDefaultParametersCommand).build() {
+};
+__name(_DescribeDefaultParametersCommand, "DescribeDefaultParametersCommand");
+var DescribeDefaultParametersCommand = _DescribeDefaultParametersCommand;
+
+// src/commands/DescribeEventsCommand.ts
+
+
+
+
+var _DescribeEventsCommand = class _DescribeEventsCommand 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("AmazonDAXV3", "DescribeEvents", {}).n("DAXClient", "DescribeEventsCommand").f(void 0, void 0).ser(se_DescribeEventsCommand).de(de_DescribeEventsCommand).build() {
+};
+__name(_DescribeEventsCommand, "DescribeEventsCommand");
+var DescribeEventsCommand = _DescribeEventsCommand;
+
+// src/commands/DescribeParameterGroupsCommand.ts
+
+
+
+
+var _DescribeParameterGroupsCommand = class _DescribeParameterGroupsCommand 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("AmazonDAXV3", "DescribeParameterGroups", {}).n("DAXClient", "DescribeParameterGroupsCommand").f(void 0, void 0).ser(se_DescribeParameterGroupsCommand).de(de_DescribeParameterGroupsCommand).build() {
+};
+__name(_DescribeParameterGroupsCommand, "DescribeParameterGroupsCommand");
+var DescribeParameterGroupsCommand = _DescribeParameterGroupsCommand;
+
+// src/commands/DescribeParametersCommand.ts
+
+
+
+
+var _DescribeParametersCommand = class _DescribeParametersCommand 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("AmazonDAXV3", "DescribeParameters", {}).n("DAXClient", "DescribeParametersCommand").f(void 0, void 0).ser(se_DescribeParametersCommand).de(de_DescribeParametersCommand).build() {
+};
+__name(_DescribeParametersCommand, "DescribeParametersCommand");
+var DescribeParametersCommand = _DescribeParametersCommand;
+
+// src/commands/DescribeSubnetGroupsCommand.ts
+
+
+
+
+var _DescribeSubnetGroupsCommand = class _DescribeSubnetGroupsCommand 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("AmazonDAXV3", "DescribeSubnetGroups", {}).n("DAXClient", "DescribeSubnetGroupsCommand").f(void 0, void 0).ser(se_DescribeSubnetGroupsCommand).de(de_DescribeSubnetGroupsCommand).build() {
+};
+__name(_DescribeSubnetGroupsCommand, "DescribeSubnetGroupsCommand");
+var DescribeSubnetGroupsCommand = _DescribeSubnetGroupsCommand;
+
+// src/commands/IncreaseReplicationFactorCommand.ts
+
+
+
+
+var _IncreaseReplicationFactorCommand = class _IncreaseReplicationFactorCommand 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("AmazonDAXV3", "IncreaseReplicationFactor", {}).n("DAXClient", "IncreaseReplicationFactorCommand").f(void 0, void 0).ser(se_IncreaseReplicationFactorCommand).de(de_IncreaseReplicationFactorCommand).build() {
+};
+__name(_IncreaseReplicationFactorCommand, "IncreaseReplicationFactorCommand");
+var IncreaseReplicationFactorCommand = _IncreaseReplicationFactorCommand;
+
+// src/commands/ListTagsCommand.ts
+
+
+
+
+var _ListTagsCommand = class _ListTagsCommand 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("AmazonDAXV3", "ListTags", {}).n("DAXClient", "ListTagsCommand").f(void 0, void 0).ser(se_ListTagsCommand).de(de_ListTagsCommand).build() {
+};
+__name(_ListTagsCommand, "ListTagsCommand");
+var ListTagsCommand = _ListTagsCommand;
+
+// src/commands/RebootNodeCommand.ts
+
+
+
+
+var _RebootNodeCommand = class _RebootNodeCommand 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("AmazonDAXV3", "RebootNode", {}).n("DAXClient", "RebootNodeCommand").f(void 0, void 0).ser(se_RebootNodeCommand).de(de_RebootNodeCommand).build() {
+};
+__name(_RebootNodeCommand, "RebootNodeCommand");
+var RebootNodeCommand = _RebootNodeCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonDAXV3", "TagResource", {}).n("DAXClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AmazonDAXV3", "UntagResource", {}).n("DAXClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateClusterCommand.ts
+
+
+
+
+var _UpdateClusterCommand = class _UpdateClusterCommand 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("AmazonDAXV3", "UpdateCluster", {}).n("DAXClient", "UpdateClusterCommand").f(void 0, void 0).ser(se_UpdateClusterCommand).de(de_UpdateClusterCommand).build() {
+};
+__name(_UpdateClusterCommand, "UpdateClusterCommand");
+var UpdateClusterCommand = _UpdateClusterCommand;
+
+// src/commands/UpdateParameterGroupCommand.ts
+
+
+
+
+var _UpdateParameterGroupCommand = class _UpdateParameterGroupCommand 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("AmazonDAXV3", "UpdateParameterGroup", {}).n("DAXClient", "UpdateParameterGroupCommand").f(void 0, void 0).ser(se_UpdateParameterGroupCommand).de(de_UpdateParameterGroupCommand).build() {
+};
+__name(_UpdateParameterGroupCommand, "UpdateParameterGroupCommand");
+var UpdateParameterGroupCommand = _UpdateParameterGroupCommand;
+
+// src/commands/UpdateSubnetGroupCommand.ts
+
+
+
+
+var _UpdateSubnetGroupCommand = class _UpdateSubnetGroupCommand 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("AmazonDAXV3", "UpdateSubnetGroup", {}).n("DAXClient", "UpdateSubnetGroupCommand").f(void 0, void 0).ser(se_UpdateSubnetGroupCommand).de(de_UpdateSubnetGroupCommand).build() {
+};
+__name(_UpdateSubnetGroupCommand, "UpdateSubnetGroupCommand");
+var UpdateSubnetGroupCommand = _UpdateSubnetGroupCommand;
+
+// src/DAX.ts
+var commands = {
+  CreateClusterCommand,
+  CreateParameterGroupCommand,
+  CreateSubnetGroupCommand,
+  DecreaseReplicationFactorCommand,
+  DeleteClusterCommand,
+  DeleteParameterGroupCommand,
+  DeleteSubnetGroupCommand,
+  DescribeClustersCommand,
+  DescribeDefaultParametersCommand,
+  DescribeEventsCommand,
+  DescribeParameterGroupsCommand,
+  DescribeParametersCommand,
+  DescribeSubnetGroupsCommand,
+  IncreaseReplicationFactorCommand,
+  ListTagsCommand,
+  RebootNodeCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateClusterCommand,
+  UpdateParameterGroupCommand,
+  UpdateSubnetGroupCommand
+};
+var _DAX = class _DAX extends DAXClient {
+};
+__name(_DAX, "DAX");
+var DAX = _DAX;
+(0, import_smithy_client.createAggregatedClient)(commands, DAX);
+
+// 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 = {
+  ChangeType,
+  ClusterAlreadyExistsFault,
+  ClusterEndpointEncryptionType,
+  ClusterNotFoundFault,
+  ClusterQuotaForCustomerExceededFault,
+  CreateClusterCommand,
+  CreateParameterGroupCommand,
+  CreateSubnetGroupCommand,
+  DAX,
+  DAXClient,
+  DAXServiceException,
+  DecreaseReplicationFactorCommand,
+  DeleteClusterCommand,
+  DeleteParameterGroupCommand,
+  DeleteSubnetGroupCommand,
+  DescribeClustersCommand,
+  DescribeDefaultParametersCommand,
+  DescribeEventsCommand,
+  DescribeParameterGroupsCommand,
+  DescribeParametersCommand,
+  DescribeSubnetGroupsCommand,
+  IncreaseReplicationFactorCommand,
+  InsufficientClusterCapacityFault,
+  InvalidARNFault,
+  InvalidClusterStateFault,
+  InvalidParameterCombinationException,
+  InvalidParameterGroupStateFault,
+  InvalidParameterValueException,
+  InvalidSubnet,
+  InvalidVPCNetworkStateFault,
+  IsModifiable,
+  ListTagsCommand,
+  NodeNotFoundFault,
+  NodeQuotaForClusterExceededFault,
+  NodeQuotaForCustomerExceededFault,
+  ParameterGroupAlreadyExistsFault,
+  ParameterGroupNotFoundFault,
+  ParameterGroupQuotaExceededFault,
+  ParameterType,
+  RebootNodeCommand,
+  SSEStatus,
+  ServiceLinkedRoleNotFoundFault,
+  ServiceQuotaExceededException,
+  SourceType,
+  SubnetGroupAlreadyExistsFault,
+  SubnetGroupInUseFault,
+  SubnetGroupNotFoundFault,
+  SubnetGroupQuotaExceededFault,
+  SubnetInUse,
+  SubnetQuotaExceededFault,
+  TagNotFoundFault,
+  TagQuotaPerResourceExceeded,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateClusterCommand,
+  UpdateParameterGroupCommand,
+  UpdateSubnetGroupCommand,
+  __Client
+});