npm - @aws-sdk/client-dax - Versions diffs - 3.899.0 → 3.906.0 - Mend

@aws-sdk/client-dax 3.899.0 → 3.906.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist-cjs/index.js +1759 -2020
package/package.json +37 -37

package/dist-cjs/index.js CHANGED Viewed

@@ -1,2099 +1,1838 @@
-"use strict";
-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 index_exports = {};
-__export(index_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,
-  NetworkType: () => NetworkType,
-  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,
-  SubnetNotAllowedFault: () => SubnetNotAllowedFault,
-  SubnetQuotaExceededFault: () => SubnetQuotaExceededFault,
-  TagNotFoundFault: () => TagNotFoundFault,
-  TagQuotaPerResourceExceeded: () => TagQuotaPerResourceExceeded,
-  TagResourceCommand: () => TagResourceCommand,
-  UntagResourceCommand: () => UntagResourceCommand,
-  UpdateClusterCommand: () => UpdateClusterCommand,
-  UpdateParameterGroupCommand: () => UpdateParameterGroupCommand,
-  UpdateSubnetGroupCommand: () => UpdateSubnetGroupCommand,
-  __Client: () => import_smithy_client.Client
-});
-module.exports = __toCommonJS(index_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_user_agent = require("@aws-sdk/middleware-user-agent");
-var import_config_resolver = require("@smithy/config-resolver");
-var import_core = require("@smithy/core");
-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");
-var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");
-// src/endpoint/EndpointParameters.ts
-var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
-  return Object.assign(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" }
+'use strict';
+var middlewareHostHeader = require('@aws-sdk/middleware-host-header');
+var middlewareLogger = require('@aws-sdk/middleware-logger');
+var middlewareRecursionDetection = require('@aws-sdk/middleware-recursion-detection');
+var middlewareUserAgent = require('@aws-sdk/middleware-user-agent');
+var configResolver = require('@smithy/config-resolver');
+var core = require('@smithy/core');
+var middlewareContentLength = require('@smithy/middleware-content-length');
+var middlewareEndpoint = require('@smithy/middleware-endpoint');
+var middlewareRetry = require('@smithy/middleware-retry');
+var smithyClient = require('@smithy/smithy-client');
+var httpAuthSchemeProvider = require('./auth/httpAuthSchemeProvider');
+var runtimeConfig = require('./runtimeConfig');
+var regionConfigResolver = require('@aws-sdk/region-config-resolver');
+var protocolHttp = require('@smithy/protocol-http');
+var middlewareSerde = require('@smithy/middleware-serde');
+var core$1 = require('@aws-sdk/core');
+const resolveClientEndpointParameters = (options) => {
+    return Object.assign(options, {
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "dax",
+    });
+};
+const 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");
+const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+    let _credentials = runtimeConfig.credentials;
+    return {
+        setHttpAuthScheme(httpAuthScheme) {
+            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+            if (index === -1) {
+                _httpAuthSchemes.push(httpAuthScheme);
+            }
+            else {
+                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+            }
+        },
+        httpAuthSchemes() {
+            return _httpAuthSchemes;
+        },
+        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+            _httpAuthSchemeProvider = httpAuthSchemeProvider;
+        },
+        httpAuthSchemeProvider() {
+            return _httpAuthSchemeProvider;
+        },
+        setCredentials(credentials) {
+            _credentials = credentials;
+        },
+        credentials() {
+            return _credentials;
+        },
+    };
+};
+const resolveHttpAuthRuntimeConfig = (config) => {
+    return {
+        httpAuthSchemes: config.httpAuthSchemes(),
+        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+        credentials: config.credentials(),
+    };
+};
-// 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");
+const resolveRuntimeExtensions = (runtimeConfig, extensions) => {
+    const extensionConfiguration = Object.assign(regionConfigResolver.getAwsRegionExtensionConfiguration(runtimeConfig), smithyClient.getDefaultExtensionConfiguration(runtimeConfig), protocolHttp.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
+    extensions.forEach((extension) => extension.configure(extensionConfiguration));
+    return Object.assign(runtimeConfig, regionConfigResolver.resolveAwsRegionExtensionConfiguration(extensionConfiguration), smithyClient.resolveDefaultRuntimeConfig(extensionConfiguration), protocolHttp.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
+};
-// src/auth/httpAuthExtensionConfiguration.ts
-var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
-  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
-  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
-  let _credentials = runtimeConfig.credentials;
-  return {
-    setHttpAuthScheme(httpAuthScheme) {
-      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
-      if (index === -1) {
-        _httpAuthSchemes.push(httpAuthScheme);
-      } else {
-        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
-      }
-    },
-    httpAuthSchemes() {
-      return _httpAuthSchemes;
-    },
-    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
-      _httpAuthSchemeProvider = httpAuthSchemeProvider;
-    },
-    httpAuthSchemeProvider() {
-      return _httpAuthSchemeProvider;
-    },
-    setCredentials(credentials) {
-      _credentials = credentials;
-    },
-    credentials() {
-      return _credentials;
+class DAXClient extends smithyClient.Client {
+    config;
+    constructor(...[configuration]) {
+        const _config_0 = runtimeConfig.getRuntimeConfig(configuration || {});
+        super(_config_0);
+        this.initConfig = _config_0;
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = middlewareUserAgent.resolveUserAgentConfig(_config_1);
+        const _config_3 = middlewareRetry.resolveRetryConfig(_config_2);
+        const _config_4 = configResolver.resolveRegionConfig(_config_3);
+        const _config_5 = middlewareHostHeader.resolveHostHeaderConfig(_config_4);
+        const _config_6 = middlewareEndpoint.resolveEndpointConfig(_config_5);
+        const _config_7 = httpAuthSchemeProvider.resolveHttpAuthSchemeConfig(_config_6);
+        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
+        this.config = _config_8;
+        this.middlewareStack.use(middlewareUserAgent.getUserAgentPlugin(this.config));
+        this.middlewareStack.use(middlewareRetry.getRetryPlugin(this.config));
+        this.middlewareStack.use(middlewareContentLength.getContentLengthPlugin(this.config));
+        this.middlewareStack.use(middlewareHostHeader.getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(middlewareLogger.getLoggerPlugin(this.config));
+        this.middlewareStack.use(middlewareRecursionDetection.getRecursionDetectionPlugin(this.config));
+        this.middlewareStack.use(core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: httpAuthSchemeProvider.defaultDAXHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
     }
-  };
-}, "getHttpAuthExtensionConfiguration");
-var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
-  return {
-    httpAuthSchemes: config.httpAuthSchemes(),
-    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
-    credentials: config.credentials()
-  };
-}, "resolveHttpAuthRuntimeConfig");
+    destroy() {
+        super.destroy();
+    }
+}
-// src/runtimeExtensions.ts
-var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
-  const extensionConfiguration = Object.assign(
-    (0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig),
-    (0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig),
-    (0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig),
-    getHttpAuthExtensionConfiguration(runtimeConfig)
-  );
-  extensions.forEach((extension) => extension.configure(extensionConfiguration));
-  return Object.assign(
-    runtimeConfig,
-    (0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
-    (0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
-    (0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
-    resolveHttpAuthRuntimeConfig(extensionConfiguration)
-  );
-}, "resolveRuntimeExtensions");
+class DAXServiceException extends smithyClient.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, DAXServiceException.prototype);
+    }
+}
-// src/DAXClient.ts
-var DAXClient = class extends import_smithy_client.Client {
-  static {
-    __name(this, "DAXClient");
-  }
-  /**
-   * The resolved configuration of DAXClient class. This is resolved and normalized from the {@link DAXClientConfig | constructor configuration interface}.
-   */
-  config;
-  constructor(...[configuration]) {
-    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
-    super(_config_0);
-    this.initConfig = _config_0;
-    const _config_1 = resolveClientEndpointParameters(_config_0);
-    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
-    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
-    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
-    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
-    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
-    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
-    const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
-    this.config = _config_8;
-    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
-    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_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
-        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultDAXHttpAuthSchemeParametersProvider,
-        identityProviderConfigProvider: /* @__PURE__ */ __name(async (config) => new import_core.DefaultIdentityProviderConfig({
-          "aws.auth#sigv4": config.credentials
-        }), "identityProviderConfigProvider")
-      })
-    );
-    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(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();
-  }
+class ClusterAlreadyExistsFault extends DAXServiceException {
+    name = "ClusterAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ClusterAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ClusterAlreadyExistsFault.prototype);
+    }
+}
+class ClusterQuotaForCustomerExceededFault extends DAXServiceException {
+    name = "ClusterQuotaForCustomerExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ClusterQuotaForCustomerExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ClusterQuotaForCustomerExceededFault.prototype);
+    }
+}
+const ClusterEndpointEncryptionType = {
+    NONE: "NONE",
+    TLS: "TLS",
 };
-// src/DAX.ts
-// src/commands/CreateClusterCommand.ts
-var import_middleware_serde = require("@smithy/middleware-serde");
-// src/protocols/Aws_json1_1.ts
-var import_core2 = require("@aws-sdk/core");
-// src/models/DAXServiceException.ts
-var DAXServiceException = class _DAXServiceException extends import_smithy_client.ServiceException {
-  static {
-    __name(this, "DAXServiceException");
-  }
-  /**
-   * @internal
-   */
-  constructor(options) {
-    super(options);
-    Object.setPrototypeOf(this, _DAXServiceException.prototype);
-  }
+const NetworkType = {
+    DUAL_STACK: "dual_stack",
+    IPV4: "ipv4",
+    IPV6: "ipv6",
 };
+const SSEStatus = {
+    DISABLED: "DISABLED",
+    DISABLING: "DISABLING",
+    ENABLED: "ENABLED",
+    ENABLING: "ENABLING",
+};
+class InsufficientClusterCapacityFault extends DAXServiceException {
+    name = "InsufficientClusterCapacityFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InsufficientClusterCapacityFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InsufficientClusterCapacityFault.prototype);
+    }
+}
+class InvalidClusterStateFault extends DAXServiceException {
+    name = "InvalidClusterStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidClusterStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidClusterStateFault.prototype);
+    }
+}
+class InvalidParameterCombinationException extends DAXServiceException {
+    name = "InvalidParameterCombinationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidParameterCombinationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidParameterCombinationException.prototype);
+    }
+}
+class InvalidParameterGroupStateFault extends DAXServiceException {
+    name = "InvalidParameterGroupStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidParameterGroupStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidParameterGroupStateFault.prototype);
+    }
+}
+class InvalidParameterValueException extends DAXServiceException {
+    name = "InvalidParameterValueException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidParameterValueException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidParameterValueException.prototype);
+    }
+}
+class InvalidVPCNetworkStateFault extends DAXServiceException {
+    name = "InvalidVPCNetworkStateFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidVPCNetworkStateFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidVPCNetworkStateFault.prototype);
+    }
+}
+class NodeQuotaForClusterExceededFault extends DAXServiceException {
+    name = "NodeQuotaForClusterExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NodeQuotaForClusterExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NodeQuotaForClusterExceededFault.prototype);
+    }
+}
+class NodeQuotaForCustomerExceededFault extends DAXServiceException {
+    name = "NodeQuotaForCustomerExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NodeQuotaForCustomerExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NodeQuotaForCustomerExceededFault.prototype);
+    }
+}
+class ParameterGroupNotFoundFault extends DAXServiceException {
+    name = "ParameterGroupNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ParameterGroupNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ParameterGroupNotFoundFault.prototype);
+    }
+}
+class ServiceLinkedRoleNotFoundFault extends DAXServiceException {
+    name = "ServiceLinkedRoleNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServiceLinkedRoleNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceLinkedRoleNotFoundFault.prototype);
+    }
+}
+class ServiceQuotaExceededException extends DAXServiceException {
+    name = "ServiceQuotaExceededException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+    }
+}
+class SubnetGroupNotFoundFault extends DAXServiceException {
+    name = "SubnetGroupNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SubnetGroupNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SubnetGroupNotFoundFault.prototype);
+    }
+}
+class TagQuotaPerResourceExceeded extends DAXServiceException {
+    name = "TagQuotaPerResourceExceeded";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TagQuotaPerResourceExceeded",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagQuotaPerResourceExceeded.prototype);
+    }
+}
+class ParameterGroupAlreadyExistsFault extends DAXServiceException {
+    name = "ParameterGroupAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ParameterGroupAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ParameterGroupAlreadyExistsFault.prototype);
+    }
+}
+class ParameterGroupQuotaExceededFault extends DAXServiceException {
+    name = "ParameterGroupQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ParameterGroupQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ParameterGroupQuotaExceededFault.prototype);
+    }
+}
+class InvalidSubnet extends DAXServiceException {
+    name = "InvalidSubnet";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidSubnet",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidSubnet.prototype);
+    }
+}
+class SubnetGroupAlreadyExistsFault extends DAXServiceException {
+    name = "SubnetGroupAlreadyExistsFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SubnetGroupAlreadyExistsFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SubnetGroupAlreadyExistsFault.prototype);
+    }
+}
+class SubnetGroupQuotaExceededFault extends DAXServiceException {
+    name = "SubnetGroupQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SubnetGroupQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SubnetGroupQuotaExceededFault.prototype);
+    }
+}
+class SubnetNotAllowedFault extends DAXServiceException {
+    name = "SubnetNotAllowedFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SubnetNotAllowedFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SubnetNotAllowedFault.prototype);
+    }
+}
+class SubnetQuotaExceededFault extends DAXServiceException {
+    name = "SubnetQuotaExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SubnetQuotaExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SubnetQuotaExceededFault.prototype);
+    }
+}
+class ClusterNotFoundFault extends DAXServiceException {
+    name = "ClusterNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ClusterNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ClusterNotFoundFault.prototype);
+    }
+}
+class NodeNotFoundFault extends DAXServiceException {
+    name = "NodeNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "NodeNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NodeNotFoundFault.prototype);
+    }
+}
+class SubnetGroupInUseFault extends DAXServiceException {
+    name = "SubnetGroupInUseFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SubnetGroupInUseFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SubnetGroupInUseFault.prototype);
+    }
+}
+const ChangeType = {
+    IMMEDIATE: "IMMEDIATE",
+    REQUIRES_REBOOT: "REQUIRES_REBOOT",
+};
+const IsModifiable = {
+    CONDITIONAL: "CONDITIONAL",
+    FALSE: "FALSE",
+    TRUE: "TRUE",
+};
+const ParameterType = {
+    DEFAULT: "DEFAULT",
+    NODE_TYPE_SPECIFIC: "NODE_TYPE_SPECIFIC",
+};
+const SourceType = {
+    CLUSTER: "CLUSTER",
+    PARAMETER_GROUP: "PARAMETER_GROUP",
+    SUBNET_GROUP: "SUBNET_GROUP",
+};
+class InvalidARNFault extends DAXServiceException {
+    name = "InvalidARNFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidARNFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidARNFault.prototype);
+    }
+}
+class TagNotFoundFault extends DAXServiceException {
+    name = "TagNotFoundFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "TagNotFoundFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TagNotFoundFault.prototype);
+    }
+}
+class SubnetInUse extends DAXServiceException {
+    name = "SubnetInUse";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "SubnetInUse",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, SubnetInUse.prototype);
+    }
+}
-// src/models/models_0.ts
-var ClusterAlreadyExistsFault = class _ClusterAlreadyExistsFault extends DAXServiceException {
-  static {
-    __name(this, "ClusterAlreadyExistsFault");
-  }
-  name = "ClusterAlreadyExistsFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ClusterAlreadyExistsFault",
-      $fault: "client",
-      ...opts
+const se_CreateClusterCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateCluster");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_CreateParameterGroupCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateParameterGroup");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_CreateSubnetGroupCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateSubnetGroup");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DecreaseReplicationFactorCommand = async (input, context) => {
+    const headers = sharedHeaders("DecreaseReplicationFactor");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DeleteClusterCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteCluster");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DeleteParameterGroupCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteParameterGroup");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DeleteSubnetGroupCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteSubnetGroup");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DescribeClustersCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeClusters");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DescribeDefaultParametersCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeDefaultParameters");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DescribeEventsCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeEvents");
+    let body;
+    body = JSON.stringify(se_DescribeEventsRequest(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DescribeParameterGroupsCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeParameterGroups");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DescribeParametersCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeParameters");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DescribeSubnetGroupsCommand = async (input, context) => {
+    const headers = sharedHeaders("DescribeSubnetGroups");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_IncreaseReplicationFactorCommand = async (input, context) => {
+    const headers = sharedHeaders("IncreaseReplicationFactor");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListTagsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListTags");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_RebootNodeCommand = async (input, context) => {
+    const headers = sharedHeaders("RebootNode");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_TagResourceCommand = async (input, context) => {
+    const headers = sharedHeaders("TagResource");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UntagResourceCommand = async (input, context) => {
+    const headers = sharedHeaders("UntagResource");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UpdateClusterCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateCluster");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UpdateParameterGroupCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateParameterGroup");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UpdateSubnetGroupCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateSubnetGroup");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const de_CreateClusterCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_CreateClusterResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateParameterGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateSubnetGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DecreaseReplicationFactorCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_DecreaseReplicationFactorResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DeleteClusterCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_DeleteClusterResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DeleteParameterGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DeleteSubnetGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DescribeClustersCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeClustersResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DescribeDefaultParametersCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DescribeEventsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_DescribeEventsResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DescribeParameterGroupsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DescribeParametersCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DescribeSubnetGroupsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_IncreaseReplicationFactorCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_IncreaseReplicationFactorResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListTagsCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_RebootNodeCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_RebootNodeResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_TagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_UntagResourceCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_UpdateClusterCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = de_UpdateClusterResponse(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_UpdateParameterGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_UpdateSubnetGroupCommand = async (output, context) => {
+    if (output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const data = await core$1.parseJsonBody(output.body, context);
+    let contents = {};
+    contents = smithyClient._json(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CommandError = async (output, context) => {
+    const parsedOutput = {
+        ...output,
+        body: await core$1.parseJsonErrorBody(output.body, context),
+    };
+    const errorCode = core$1.loadRestJsonErrorCode(output, parsedOutput.body);
+    switch (errorCode) {
+        case "ClusterAlreadyExistsFault":
+        case "com.amazonaws.dax#ClusterAlreadyExistsFault":
+            throw await de_ClusterAlreadyExistsFaultRes(parsedOutput);
+        case "ClusterQuotaForCustomerExceededFault":
+        case "com.amazonaws.dax#ClusterQuotaForCustomerExceededFault":
+            throw await de_ClusterQuotaForCustomerExceededFaultRes(parsedOutput);
+        case "InsufficientClusterCapacityFault":
+        case "com.amazonaws.dax#InsufficientClusterCapacityFault":
+            throw await de_InsufficientClusterCapacityFaultRes(parsedOutput);
+        case "InvalidClusterStateFault":
+        case "com.amazonaws.dax#InvalidClusterStateFault":
+            throw await de_InvalidClusterStateFaultRes(parsedOutput);
+        case "InvalidParameterCombinationException":
+        case "com.amazonaws.dax#InvalidParameterCombinationException":
+            throw await de_InvalidParameterCombinationExceptionRes(parsedOutput);
+        case "InvalidParameterGroupStateFault":
+        case "com.amazonaws.dax#InvalidParameterGroupStateFault":
+            throw await de_InvalidParameterGroupStateFaultRes(parsedOutput);
+        case "InvalidParameterValueException":
+        case "com.amazonaws.dax#InvalidParameterValueException":
+            throw await de_InvalidParameterValueExceptionRes(parsedOutput);
+        case "InvalidVPCNetworkStateFault":
+        case "com.amazonaws.dax#InvalidVPCNetworkStateFault":
+            throw await de_InvalidVPCNetworkStateFaultRes(parsedOutput);
+        case "NodeQuotaForClusterExceededFault":
+        case "com.amazonaws.dax#NodeQuotaForClusterExceededFault":
+            throw await de_NodeQuotaForClusterExceededFaultRes(parsedOutput);
+        case "NodeQuotaForCustomerExceededFault":
+        case "com.amazonaws.dax#NodeQuotaForCustomerExceededFault":
+            throw await de_NodeQuotaForCustomerExceededFaultRes(parsedOutput);
+        case "ParameterGroupNotFoundFault":
+        case "com.amazonaws.dax#ParameterGroupNotFoundFault":
+            throw await de_ParameterGroupNotFoundFaultRes(parsedOutput);
+        case "ServiceLinkedRoleNotFoundFault":
+        case "com.amazonaws.dax#ServiceLinkedRoleNotFoundFault":
+            throw await de_ServiceLinkedRoleNotFoundFaultRes(parsedOutput);
+        case "ServiceQuotaExceededException":
+        case "com.amazonaws.dax#ServiceQuotaExceededException":
+            throw await de_ServiceQuotaExceededExceptionRes(parsedOutput);
+        case "SubnetGroupNotFoundFault":
+        case "com.amazonaws.dax#SubnetGroupNotFoundFault":
+            throw await de_SubnetGroupNotFoundFaultRes(parsedOutput);
+        case "TagQuotaPerResourceExceeded":
+        case "com.amazonaws.dax#TagQuotaPerResourceExceeded":
+            throw await de_TagQuotaPerResourceExceededRes(parsedOutput);
+        case "ParameterGroupAlreadyExistsFault":
+        case "com.amazonaws.dax#ParameterGroupAlreadyExistsFault":
+            throw await de_ParameterGroupAlreadyExistsFaultRes(parsedOutput);
+        case "ParameterGroupQuotaExceededFault":
+        case "com.amazonaws.dax#ParameterGroupQuotaExceededFault":
+            throw await de_ParameterGroupQuotaExceededFaultRes(parsedOutput);
+        case "InvalidSubnet":
+        case "com.amazonaws.dax#InvalidSubnet":
+            throw await de_InvalidSubnetRes(parsedOutput);
+        case "SubnetGroupAlreadyExistsFault":
+        case "com.amazonaws.dax#SubnetGroupAlreadyExistsFault":
+            throw await de_SubnetGroupAlreadyExistsFaultRes(parsedOutput);
+        case "SubnetGroupQuotaExceededFault":
+        case "com.amazonaws.dax#SubnetGroupQuotaExceededFault":
+            throw await de_SubnetGroupQuotaExceededFaultRes(parsedOutput);
+        case "SubnetNotAllowedFault":
+        case "com.amazonaws.dax#SubnetNotAllowedFault":
+            throw await de_SubnetNotAllowedFaultRes(parsedOutput);
+        case "SubnetQuotaExceededFault":
+        case "com.amazonaws.dax#SubnetQuotaExceededFault":
+            throw await de_SubnetQuotaExceededFaultRes(parsedOutput);
+        case "ClusterNotFoundFault":
+        case "com.amazonaws.dax#ClusterNotFoundFault":
+            throw await de_ClusterNotFoundFaultRes(parsedOutput);
+        case "NodeNotFoundFault":
+        case "com.amazonaws.dax#NodeNotFoundFault":
+            throw await de_NodeNotFoundFaultRes(parsedOutput);
+        case "SubnetGroupInUseFault":
+        case "com.amazonaws.dax#SubnetGroupInUseFault":
+            throw await de_SubnetGroupInUseFaultRes(parsedOutput);
+        case "InvalidARNFault":
+        case "com.amazonaws.dax#InvalidARNFault":
+            throw await de_InvalidARNFaultRes(parsedOutput);
+        case "TagNotFoundFault":
+        case "com.amazonaws.dax#TagNotFoundFault":
+            throw await de_TagNotFoundFaultRes(parsedOutput);
+        case "SubnetInUse":
+        case "com.amazonaws.dax#SubnetInUse":
+            throw await de_SubnetInUseRes(parsedOutput);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+const de_ClusterAlreadyExistsFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ClusterAlreadyExistsFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ClusterAlreadyExistsFault.prototype);
-  }
-};
-var ClusterQuotaForCustomerExceededFault = class _ClusterQuotaForCustomerExceededFault extends DAXServiceException {
-  static {
-    __name(this, "ClusterQuotaForCustomerExceededFault");
-  }
-  name = "ClusterQuotaForCustomerExceededFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ClusterQuotaForCustomerExceededFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ClusterNotFoundFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ClusterNotFoundFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ClusterQuotaForCustomerExceededFault.prototype);
-  }
-};
-var ClusterEndpointEncryptionType = {
-  NONE: "NONE",
-  TLS: "TLS"
-};
-var NetworkType = {
-  DUAL_STACK: "dual_stack",
-  IPV4: "ipv4",
-  IPV6: "ipv6"
-};
-var SSEStatus = {
-  DISABLED: "DISABLED",
-  DISABLING: "DISABLING",
-  ENABLED: "ENABLED",
-  ENABLING: "ENABLING"
-};
-var InsufficientClusterCapacityFault = class _InsufficientClusterCapacityFault extends DAXServiceException {
-  static {
-    __name(this, "InsufficientClusterCapacityFault");
-  }
-  name = "InsufficientClusterCapacityFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InsufficientClusterCapacityFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ClusterQuotaForCustomerExceededFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ClusterQuotaForCustomerExceededFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InsufficientClusterCapacityFault.prototype);
-  }
-};
-var InvalidClusterStateFault = class _InvalidClusterStateFault extends DAXServiceException {
-  static {
-    __name(this, "InvalidClusterStateFault");
-  }
-  name = "InvalidClusterStateFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidClusterStateFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InsufficientClusterCapacityFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InsufficientClusterCapacityFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidClusterStateFault.prototype);
-  }
-};
-var InvalidParameterCombinationException = class _InvalidParameterCombinationException extends DAXServiceException {
-  static {
-    __name(this, "InvalidParameterCombinationException");
-  }
-  name = "InvalidParameterCombinationException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidParameterCombinationException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidARNFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidARNFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidParameterCombinationException.prototype);
-  }
-};
-var InvalidParameterGroupStateFault = class _InvalidParameterGroupStateFault extends DAXServiceException {
-  static {
-    __name(this, "InvalidParameterGroupStateFault");
-  }
-  name = "InvalidParameterGroupStateFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidParameterGroupStateFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidClusterStateFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidClusterStateFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidParameterGroupStateFault.prototype);
-  }
-};
-var InvalidParameterValueException = class _InvalidParameterValueException extends DAXServiceException {
-  static {
-    __name(this, "InvalidParameterValueException");
-  }
-  name = "InvalidParameterValueException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidParameterValueException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidParameterCombinationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidParameterCombinationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidParameterValueException.prototype);
-  }
-};
-var InvalidVPCNetworkStateFault = class _InvalidVPCNetworkStateFault extends DAXServiceException {
-  static {
-    __name(this, "InvalidVPCNetworkStateFault");
-  }
-  name = "InvalidVPCNetworkStateFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidVPCNetworkStateFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidParameterGroupStateFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidParameterGroupStateFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidVPCNetworkStateFault.prototype);
-  }
-};
-var NodeQuotaForClusterExceededFault = class _NodeQuotaForClusterExceededFault extends DAXServiceException {
-  static {
-    __name(this, "NodeQuotaForClusterExceededFault");
-  }
-  name = "NodeQuotaForClusterExceededFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "NodeQuotaForClusterExceededFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidParameterValueExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidParameterValueException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _NodeQuotaForClusterExceededFault.prototype);
-  }
-};
-var NodeQuotaForCustomerExceededFault = class _NodeQuotaForCustomerExceededFault extends DAXServiceException {
-  static {
-    __name(this, "NodeQuotaForCustomerExceededFault");
-  }
-  name = "NodeQuotaForCustomerExceededFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "NodeQuotaForCustomerExceededFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidSubnetRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidSubnet({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _NodeQuotaForCustomerExceededFault.prototype);
-  }
-};
-var ParameterGroupNotFoundFault = class _ParameterGroupNotFoundFault extends DAXServiceException {
-  static {
-    __name(this, "ParameterGroupNotFoundFault");
-  }
-  name = "ParameterGroupNotFoundFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ParameterGroupNotFoundFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidVPCNetworkStateFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidVPCNetworkStateFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ParameterGroupNotFoundFault.prototype);
-  }
-};
-var ServiceLinkedRoleNotFoundFault = class _ServiceLinkedRoleNotFoundFault extends DAXServiceException {
-  static {
-    __name(this, "ServiceLinkedRoleNotFoundFault");
-  }
-  name = "ServiceLinkedRoleNotFoundFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ServiceLinkedRoleNotFoundFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_NodeNotFoundFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new NodeNotFoundFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ServiceLinkedRoleNotFoundFault.prototype);
-  }
-};
-var ServiceQuotaExceededException = class _ServiceQuotaExceededException extends DAXServiceException {
-  static {
-    __name(this, "ServiceQuotaExceededException");
-  }
-  name = "ServiceQuotaExceededException";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ServiceQuotaExceededException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_NodeQuotaForClusterExceededFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new NodeQuotaForClusterExceededFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
-  }
-};
-var SubnetGroupNotFoundFault = class _SubnetGroupNotFoundFault extends DAXServiceException {
-  static {
-    __name(this, "SubnetGroupNotFoundFault");
-  }
-  name = "SubnetGroupNotFoundFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "SubnetGroupNotFoundFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_NodeQuotaForCustomerExceededFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new NodeQuotaForCustomerExceededFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _SubnetGroupNotFoundFault.prototype);
-  }
-};
-var TagQuotaPerResourceExceeded = class _TagQuotaPerResourceExceeded extends DAXServiceException {
-  static {
-    __name(this, "TagQuotaPerResourceExceeded");
-  }
-  name = "TagQuotaPerResourceExceeded";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "TagQuotaPerResourceExceeded",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ParameterGroupAlreadyExistsFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ParameterGroupAlreadyExistsFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _TagQuotaPerResourceExceeded.prototype);
-  }
-};
-var ParameterGroupAlreadyExistsFault = class _ParameterGroupAlreadyExistsFault extends DAXServiceException {
-  static {
-    __name(this, "ParameterGroupAlreadyExistsFault");
-  }
-  name = "ParameterGroupAlreadyExistsFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ParameterGroupAlreadyExistsFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ParameterGroupNotFoundFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ParameterGroupNotFoundFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ParameterGroupAlreadyExistsFault.prototype);
-  }
-};
-var ParameterGroupQuotaExceededFault = class _ParameterGroupQuotaExceededFault extends DAXServiceException {
-  static {
-    __name(this, "ParameterGroupQuotaExceededFault");
-  }
-  name = "ParameterGroupQuotaExceededFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ParameterGroupQuotaExceededFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ParameterGroupQuotaExceededFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ParameterGroupQuotaExceededFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ParameterGroupQuotaExceededFault.prototype);
-  }
-};
-var InvalidSubnet = class _InvalidSubnet extends DAXServiceException {
-  static {
-    __name(this, "InvalidSubnet");
-  }
-  name = "InvalidSubnet";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidSubnet",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ServiceLinkedRoleNotFoundFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ServiceLinkedRoleNotFoundFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidSubnet.prototype);
-  }
-};
-var SubnetGroupAlreadyExistsFault = class _SubnetGroupAlreadyExistsFault extends DAXServiceException {
-  static {
-    __name(this, "SubnetGroupAlreadyExistsFault");
-  }
-  name = "SubnetGroupAlreadyExistsFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "SubnetGroupAlreadyExistsFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ServiceQuotaExceededExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ServiceQuotaExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _SubnetGroupAlreadyExistsFault.prototype);
-  }
-};
-var SubnetGroupQuotaExceededFault = class _SubnetGroupQuotaExceededFault extends DAXServiceException {
-  static {
-    __name(this, "SubnetGroupQuotaExceededFault");
-  }
-  name = "SubnetGroupQuotaExceededFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "SubnetGroupQuotaExceededFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_SubnetGroupAlreadyExistsFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new SubnetGroupAlreadyExistsFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _SubnetGroupQuotaExceededFault.prototype);
-  }
-};
-var SubnetNotAllowedFault = class _SubnetNotAllowedFault extends DAXServiceException {
-  static {
-    __name(this, "SubnetNotAllowedFault");
-  }
-  name = "SubnetNotAllowedFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "SubnetNotAllowedFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_SubnetGroupInUseFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new SubnetGroupInUseFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _SubnetNotAllowedFault.prototype);
-  }
-};
-var SubnetQuotaExceededFault = class _SubnetQuotaExceededFault extends DAXServiceException {
-  static {
-    __name(this, "SubnetQuotaExceededFault");
-  }
-  name = "SubnetQuotaExceededFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "SubnetQuotaExceededFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_SubnetGroupNotFoundFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new SubnetGroupNotFoundFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _SubnetQuotaExceededFault.prototype);
-  }
-};
-var ClusterNotFoundFault = class _ClusterNotFoundFault extends DAXServiceException {
-  static {
-    __name(this, "ClusterNotFoundFault");
-  }
-  name = "ClusterNotFoundFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ClusterNotFoundFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_SubnetGroupQuotaExceededFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new SubnetGroupQuotaExceededFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ClusterNotFoundFault.prototype);
-  }
-};
-var NodeNotFoundFault = class _NodeNotFoundFault extends DAXServiceException {
-  static {
-    __name(this, "NodeNotFoundFault");
-  }
-  name = "NodeNotFoundFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "NodeNotFoundFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_SubnetInUseRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new SubnetInUse({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _NodeNotFoundFault.prototype);
-  }
-};
-var SubnetGroupInUseFault = class _SubnetGroupInUseFault extends DAXServiceException {
-  static {
-    __name(this, "SubnetGroupInUseFault");
-  }
-  name = "SubnetGroupInUseFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "SubnetGroupInUseFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_SubnetNotAllowedFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new SubnetNotAllowedFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _SubnetGroupInUseFault.prototype);
-  }
-};
-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 {
-  static {
-    __name(this, "InvalidARNFault");
-  }
-  name = "InvalidARNFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidARNFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_SubnetQuotaExceededFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new SubnetQuotaExceededFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidARNFault.prototype);
-  }
-};
-var TagNotFoundFault = class _TagNotFoundFault extends DAXServiceException {
-  static {
-    __name(this, "TagNotFoundFault");
-  }
-  name = "TagNotFoundFault";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "TagNotFoundFault",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_TagNotFoundFaultRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new TagNotFoundFault({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _TagNotFoundFault.prototype);
-  }
-};
-var SubnetInUse = class _SubnetInUse extends DAXServiceException {
-  static {
-    __name(this, "SubnetInUse");
-  }
-  name = "SubnetInUse";
-  $fault = "client";
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "SubnetInUse",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_TagQuotaPerResourceExceededRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new TagQuotaPerResourceExceeded({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _SubnetInUse.prototype);
-  }
+    return smithyClient.decorateServiceException(exception, body);
 };
-// 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_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_CreateClusterResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateClusterCommand");
-var de_CreateParameterGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateParameterGroupCommand");
-var de_CreateSubnetGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateSubnetGroupCommand");
-var de_DecreaseReplicationFactorCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DecreaseReplicationFactorResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DecreaseReplicationFactorCommand");
-var de_DeleteClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DeleteClusterResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DeleteClusterCommand");
-var de_DeleteParameterGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DeleteParameterGroupCommand");
-var de_DeleteSubnetGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DeleteSubnetGroupCommand");
-var de_DescribeClustersCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DescribeClustersResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeClustersCommand");
-var de_DescribeDefaultParametersCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeDefaultParametersCommand");
-var de_DescribeEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_DescribeEventsResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeEventsCommand");
-var de_DescribeParameterGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeParameterGroupsCommand");
-var de_DescribeParametersCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeParametersCommand");
-var de_DescribeSubnetGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DescribeSubnetGroupsCommand");
-var de_IncreaseReplicationFactorCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_IncreaseReplicationFactorResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_IncreaseReplicationFactorCommand");
-var de_ListTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListTagsCommand");
-var de_RebootNodeCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_RebootNodeResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_RebootNodeCommand");
-var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_TagResourceCommand");
-var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UntagResourceCommand");
-var de_UpdateClusterCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = de_UpdateClusterResponse(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UpdateClusterCommand");
-var de_UpdateParameterGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UpdateParameterGroupCommand");
-var de_UpdateSubnetGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
-  if (output.statusCode >= 300) {
-    return de_CommandError(output, context);
-  }
-  const data = await (0, import_core2.parseJsonBody)(output.body, context);
-  let contents = {};
-  contents = (0, import_smithy_client._json)(data);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UpdateSubnetGroupCommand");
-var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
-  const parsedOutput = {
-    ...output,
-    body: await (0, import_core2.parseJsonErrorBody)(output.body, context)
-  };
-  const errorCode = (0, import_core2.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);
-    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 "InvalidSubnet":
-    case "com.amazonaws.dax#InvalidSubnet":
-      throw await de_InvalidSubnetRes(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 "SubnetNotAllowedFault":
-    case "com.amazonaws.dax#SubnetNotAllowedFault":
-      throw await de_SubnetNotAllowedFaultRes(parsedOutput, context);
-    case "SubnetQuotaExceededFault":
-    case "com.amazonaws.dax#SubnetQuotaExceededFault":
-      throw await de_SubnetQuotaExceededFaultRes(parsedOutput, context);
-    case "ClusterNotFoundFault":
-    case "com.amazonaws.dax#ClusterNotFoundFault":
-      throw await de_ClusterNotFoundFaultRes(parsedOutput, context);
-    case "NodeNotFoundFault":
-    case "com.amazonaws.dax#NodeNotFoundFault":
-      throw await de_NodeNotFoundFaultRes(parsedOutput, context);
-    case "SubnetGroupInUseFault":
-    case "com.amazonaws.dax#SubnetGroupInUseFault":
-      throw await de_SubnetGroupInUseFaultRes(parsedOutput, context);
-    case "InvalidARNFault":
-    case "com.amazonaws.dax#InvalidARNFault":
-      throw await de_InvalidARNFaultRes(parsedOutput, context);
-    case "TagNotFoundFault":
-    case "com.amazonaws.dax#TagNotFoundFault":
-      throw await de_TagNotFoundFaultRes(parsedOutput, context);
-    case "SubnetInUse":
-    case "com.amazonaws.dax#SubnetInUse":
-      throw await de_SubnetInUseRes(parsedOutput, context);
-    default:
-      const parsedBody = parsedOutput.body;
-      return throwDefaultError({
-        output,
-        parsedBody,
-        errorCode
-      });
-  }
-}, "de_CommandError");
-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_SubnetNotAllowedFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new SubnetNotAllowedFault({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_SubnetNotAllowedFaultRes");
-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: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "EndTime"),
-    MaxResults: [],
-    NextToken: [],
-    SourceName: [],
-    SourceType: [],
-    StartTime: /* @__PURE__ */ __name((_) => _.getTime() / 1e3, "StartTime")
-  });
-}, "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,
-    NetworkType: import_smithy_client.expectString,
-    NodeIdsToRemove: import_smithy_client._json,
-    NodeType: import_smithy_client.expectString,
-    Nodes: /* @__PURE__ */ __name((_) => de_NodeList(_, context), "Nodes"),
-    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: /* @__PURE__ */ __name((_) => de_Cluster(_, context), "Cluster")
-  });
-}, "de_CreateClusterResponse");
-var de_DecreaseReplicationFactorResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    Cluster: /* @__PURE__ */ __name((_) => de_Cluster(_, context), "Cluster")
-  });
-}, "de_DecreaseReplicationFactorResponse");
-var de_DeleteClusterResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    Cluster: /* @__PURE__ */ __name((_) => de_Cluster(_, context), "Cluster")
-  });
-}, "de_DeleteClusterResponse");
-var de_DescribeClustersResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    Clusters: /* @__PURE__ */ __name((_) => de_ClusterList(_, context), "Clusters"),
-    NextToken: import_smithy_client.expectString
-  });
-}, "de_DescribeClustersResponse");
-var de_DescribeEventsResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    Events: /* @__PURE__ */ __name((_) => de_EventList(_, context), "Events"),
-    NextToken: import_smithy_client.expectString
-  });
-}, "de_DescribeEventsResponse");
-var de_Event = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    Date: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "Date"),
-    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: /* @__PURE__ */ __name((_) => de_Cluster(_, context), "Cluster")
-  });
-}, "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: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "NodeCreateTime"),
-    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: /* @__PURE__ */ __name((_) => de_Cluster(_, context), "Cluster")
-  });
-}, "de_RebootNodeResponse");
-var de_UpdateClusterResponse = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    Cluster: /* @__PURE__ */ __name((_) => de_Cluster(_, context), "Cluster")
-  });
-}, "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 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");
-// src/commands/CreateClusterCommand.ts
-var CreateClusterCommand = class 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() {
-  static {
-    __name(this, "CreateClusterCommand");
-  }
+const se_DescribeEventsRequest = (input, context) => {
+    return smithyClient.take(input, {
+        Duration: [],
+        EndTime: (_) => _.getTime() / 1_000,
+        MaxResults: [],
+        NextToken: [],
+        SourceName: [],
+        SourceType: [],
+        StartTime: (_) => _.getTime() / 1_000,
+    });
 };
-// src/commands/CreateParameterGroupCommand.ts
-var CreateParameterGroupCommand = class 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() {
-  static {
-    __name(this, "CreateParameterGroupCommand");
-  }
+const de_Cluster = (output, context) => {
+    return smithyClient.take(output, {
+        ActiveNodes: smithyClient.expectInt32,
+        ClusterArn: smithyClient.expectString,
+        ClusterDiscoveryEndpoint: smithyClient._json,
+        ClusterEndpointEncryptionType: smithyClient.expectString,
+        ClusterName: smithyClient.expectString,
+        Description: smithyClient.expectString,
+        IamRoleArn: smithyClient.expectString,
+        NetworkType: smithyClient.expectString,
+        NodeIdsToRemove: smithyClient._json,
+        NodeType: smithyClient.expectString,
+        Nodes: (_) => de_NodeList(_),
+        NotificationConfiguration: smithyClient._json,
+        ParameterGroup: smithyClient._json,
+        PreferredMaintenanceWindow: smithyClient.expectString,
+        SSEDescription: smithyClient._json,
+        SecurityGroups: smithyClient._json,
+        Status: smithyClient.expectString,
+        SubnetGroup: smithyClient.expectString,
+        TotalNodes: smithyClient.expectInt32,
+    });
 };
-// src/commands/CreateSubnetGroupCommand.ts
-var CreateSubnetGroupCommand = class 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() {
-  static {
-    __name(this, "CreateSubnetGroupCommand");
-  }
+const de_ClusterList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Cluster(entry);
+    });
+    return retVal;
 };
-// src/commands/DecreaseReplicationFactorCommand.ts
-var DecreaseReplicationFactorCommand = class 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() {
-  static {
-    __name(this, "DecreaseReplicationFactorCommand");
-  }
+const de_CreateClusterResponse = (output, context) => {
+    return smithyClient.take(output, {
+        Cluster: (_) => de_Cluster(_),
+    });
 };
-// src/commands/DeleteClusterCommand.ts
-var DeleteClusterCommand = class 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() {
-  static {
-    __name(this, "DeleteClusterCommand");
-  }
+const de_DecreaseReplicationFactorResponse = (output, context) => {
+    return smithyClient.take(output, {
+        Cluster: (_) => de_Cluster(_),
+    });
 };
-// src/commands/DeleteParameterGroupCommand.ts
-var DeleteParameterGroupCommand = class 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() {
-  static {
-    __name(this, "DeleteParameterGroupCommand");
-  }
+const de_DeleteClusterResponse = (output, context) => {
+    return smithyClient.take(output, {
+        Cluster: (_) => de_Cluster(_),
+    });
 };
-// src/commands/DeleteSubnetGroupCommand.ts
-var DeleteSubnetGroupCommand = class 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() {
-  static {
-    __name(this, "DeleteSubnetGroupCommand");
-  }
+const de_DescribeClustersResponse = (output, context) => {
+    return smithyClient.take(output, {
+        Clusters: (_) => de_ClusterList(_),
+        NextToken: smithyClient.expectString,
+    });
 };
-// src/commands/DescribeClustersCommand.ts
-var DescribeClustersCommand = class 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() {
-  static {
-    __name(this, "DescribeClustersCommand");
-  }
+const de_DescribeEventsResponse = (output, context) => {
+    return smithyClient.take(output, {
+        Events: (_) => de_EventList(_),
+        NextToken: smithyClient.expectString,
+    });
 };
-// src/commands/DescribeDefaultParametersCommand.ts
-var DescribeDefaultParametersCommand = class 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() {
-  static {
-    __name(this, "DescribeDefaultParametersCommand");
-  }
+const de_Event = (output, context) => {
+    return smithyClient.take(output, {
+        Date: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        Message: smithyClient.expectString,
+        SourceName: smithyClient.expectString,
+        SourceType: smithyClient.expectString,
+    });
 };
-// src/commands/DescribeEventsCommand.ts
-var DescribeEventsCommand = class 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() {
-  static {
-    __name(this, "DescribeEventsCommand");
-  }
+const de_EventList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Event(entry);
+    });
+    return retVal;
 };
-// src/commands/DescribeParameterGroupsCommand.ts
-var DescribeParameterGroupsCommand = class 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() {
-  static {
-    __name(this, "DescribeParameterGroupsCommand");
-  }
+const de_IncreaseReplicationFactorResponse = (output, context) => {
+    return smithyClient.take(output, {
+        Cluster: (_) => de_Cluster(_),
+    });
 };
-// src/commands/DescribeParametersCommand.ts
-var DescribeParametersCommand = class 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() {
-  static {
-    __name(this, "DescribeParametersCommand");
-  }
+const de_Node = (output, context) => {
+    return smithyClient.take(output, {
+        AvailabilityZone: smithyClient.expectString,
+        Endpoint: smithyClient._json,
+        NodeCreateTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        NodeId: smithyClient.expectString,
+        NodeStatus: smithyClient.expectString,
+        ParameterGroupStatus: smithyClient.expectString,
+    });
 };
-// src/commands/DescribeSubnetGroupsCommand.ts
-var DescribeSubnetGroupsCommand = class 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() {
-  static {
-    __name(this, "DescribeSubnetGroupsCommand");
-  }
+const de_NodeList = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_Node(entry);
+    });
+    return retVal;
 };
-// src/commands/IncreaseReplicationFactorCommand.ts
-var IncreaseReplicationFactorCommand = class 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() {
-  static {
-    __name(this, "IncreaseReplicationFactorCommand");
-  }
+const de_RebootNodeResponse = (output, context) => {
+    return smithyClient.take(output, {
+        Cluster: (_) => de_Cluster(_),
+    });
 };
-// src/commands/ListTagsCommand.ts
-var ListTagsCommand = class 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() {
-  static {
-    __name(this, "ListTagsCommand");
-  }
+const de_UpdateClusterResponse = (output, context) => {
+    return smithyClient.take(output, {
+        Cluster: (_) => de_Cluster(_),
+    });
 };
+const deserializeMetadata = (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"],
+});
+const throwDefaultError = smithyClient.withBaseException(DAXServiceException);
+const buildHttpRpcRequest = 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 (body !== undefined) {
+        contents.body = body;
+    }
+    return new protocolHttp.HttpRequest(contents);
+};
+function sharedHeaders(operation) {
+    return {
+        "content-type": "application/x-amz-json-1.1",
+        "x-amz-target": `AmazonDAXV3.${operation}`,
+    };
+}
-// src/commands/RebootNodeCommand.ts
+class CreateClusterCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "CreateCluster", {})
+    .n("DAXClient", "CreateClusterCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateClusterCommand)
+    .de(de_CreateClusterCommand)
+    .build() {
+}
-var RebootNodeCommand = class 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() {
-  static {
-    __name(this, "RebootNodeCommand");
-  }
-};
+class CreateParameterGroupCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "CreateParameterGroup", {})
+    .n("DAXClient", "CreateParameterGroupCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateParameterGroupCommand)
+    .de(de_CreateParameterGroupCommand)
+    .build() {
+}
-// src/commands/TagResourceCommand.ts
+class CreateSubnetGroupCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "CreateSubnetGroup", {})
+    .n("DAXClient", "CreateSubnetGroupCommand")
+    .f(void 0, void 0)
+    .ser(se_CreateSubnetGroupCommand)
+    .de(de_CreateSubnetGroupCommand)
+    .build() {
+}
+class DecreaseReplicationFactorCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "DecreaseReplicationFactor", {})
+    .n("DAXClient", "DecreaseReplicationFactorCommand")
+    .f(void 0, void 0)
+    .ser(se_DecreaseReplicationFactorCommand)
+    .de(de_DecreaseReplicationFactorCommand)
+    .build() {
+}
+class DeleteClusterCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "DeleteCluster", {})
+    .n("DAXClient", "DeleteClusterCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteClusterCommand)
+    .de(de_DeleteClusterCommand)
+    .build() {
+}
-var TagResourceCommand = class 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() {
-  static {
-    __name(this, "TagResourceCommand");
-  }
-};
+class DeleteParameterGroupCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "DeleteParameterGroup", {})
+    .n("DAXClient", "DeleteParameterGroupCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteParameterGroupCommand)
+    .de(de_DeleteParameterGroupCommand)
+    .build() {
+}
-// src/commands/UntagResourceCommand.ts
+class DeleteSubnetGroupCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "DeleteSubnetGroup", {})
+    .n("DAXClient", "DeleteSubnetGroupCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteSubnetGroupCommand)
+    .de(de_DeleteSubnetGroupCommand)
+    .build() {
+}
+class DescribeClustersCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "DescribeClusters", {})
+    .n("DAXClient", "DescribeClustersCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeClustersCommand)
+    .de(de_DescribeClustersCommand)
+    .build() {
+}
+class DescribeDefaultParametersCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "DescribeDefaultParameters", {})
+    .n("DAXClient", "DescribeDefaultParametersCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeDefaultParametersCommand)
+    .de(de_DescribeDefaultParametersCommand)
+    .build() {
+}
-var UntagResourceCommand = class 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() {
-  static {
-    __name(this, "UntagResourceCommand");
-  }
-};
+class DescribeEventsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "DescribeEvents", {})
+    .n("DAXClient", "DescribeEventsCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeEventsCommand)
+    .de(de_DescribeEventsCommand)
+    .build() {
+}
-// src/commands/UpdateClusterCommand.ts
+class DescribeParameterGroupsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "DescribeParameterGroups", {})
+    .n("DAXClient", "DescribeParameterGroupsCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeParameterGroupsCommand)
+    .de(de_DescribeParameterGroupsCommand)
+    .build() {
+}
+class DescribeParametersCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "DescribeParameters", {})
+    .n("DAXClient", "DescribeParametersCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeParametersCommand)
+    .de(de_DescribeParametersCommand)
+    .build() {
+}
+class DescribeSubnetGroupsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "DescribeSubnetGroups", {})
+    .n("DAXClient", "DescribeSubnetGroupsCommand")
+    .f(void 0, void 0)
+    .ser(se_DescribeSubnetGroupsCommand)
+    .de(de_DescribeSubnetGroupsCommand)
+    .build() {
+}
-var UpdateClusterCommand = class 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() {
-  static {
-    __name(this, "UpdateClusterCommand");
-  }
-};
+class IncreaseReplicationFactorCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "IncreaseReplicationFactor", {})
+    .n("DAXClient", "IncreaseReplicationFactorCommand")
+    .f(void 0, void 0)
+    .ser(se_IncreaseReplicationFactorCommand)
+    .de(de_IncreaseReplicationFactorCommand)
+    .build() {
+}
-// src/commands/UpdateParameterGroupCommand.ts
+class ListTagsCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "ListTags", {})
+    .n("DAXClient", "ListTagsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListTagsCommand)
+    .de(de_ListTagsCommand)
+    .build() {
+}
+class RebootNodeCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "RebootNode", {})
+    .n("DAXClient", "RebootNodeCommand")
+    .f(void 0, void 0)
+    .ser(se_RebootNodeCommand)
+    .de(de_RebootNodeCommand)
+    .build() {
+}
+class TagResourceCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "TagResource", {})
+    .n("DAXClient", "TagResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_TagResourceCommand)
+    .de(de_TagResourceCommand)
+    .build() {
+}
-var UpdateParameterGroupCommand = class 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() {
-  static {
-    __name(this, "UpdateParameterGroupCommand");
-  }
-};
+class UntagResourceCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "UntagResource", {})
+    .n("DAXClient", "UntagResourceCommand")
+    .f(void 0, void 0)
+    .ser(se_UntagResourceCommand)
+    .de(de_UntagResourceCommand)
+    .build() {
+}
-// src/commands/UpdateSubnetGroupCommand.ts
+class UpdateClusterCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "UpdateCluster", {})
+    .n("DAXClient", "UpdateClusterCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateClusterCommand)
+    .de(de_UpdateClusterCommand)
+    .build() {
+}
+class UpdateParameterGroupCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "UpdateParameterGroup", {})
+    .n("DAXClient", "UpdateParameterGroupCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateParameterGroupCommand)
+    .de(de_UpdateParameterGroupCommand)
+    .build() {
+}
+class UpdateSubnetGroupCommand extends smithyClient.Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [
+        middlewareSerde.getSerdePlugin(config, this.serialize, this.deserialize),
+        middlewareEndpoint.getEndpointPlugin(config, Command.getEndpointParameterInstructions()),
+    ];
+})
+    .s("AmazonDAXV3", "UpdateSubnetGroup", {})
+    .n("DAXClient", "UpdateSubnetGroupCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateSubnetGroupCommand)
+    .de(de_UpdateSubnetGroupCommand)
+    .build() {
+}
-var UpdateSubnetGroupCommand = class 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() {
-  static {
-    __name(this, "UpdateSubnetGroupCommand");
-  }
+const commands = {
+    CreateClusterCommand,
+    CreateParameterGroupCommand,
+    CreateSubnetGroupCommand,
+    DecreaseReplicationFactorCommand,
+    DeleteClusterCommand,
+    DeleteParameterGroupCommand,
+    DeleteSubnetGroupCommand,
+    DescribeClustersCommand,
+    DescribeDefaultParametersCommand,
+    DescribeEventsCommand,
+    DescribeParameterGroupsCommand,
+    DescribeParametersCommand,
+    DescribeSubnetGroupsCommand,
+    IncreaseReplicationFactorCommand,
+    ListTagsCommand,
+    RebootNodeCommand,
+    TagResourceCommand,
+    UntagResourceCommand,
+    UpdateClusterCommand,
+    UpdateParameterGroupCommand,
+    UpdateSubnetGroupCommand,
 };
+class DAX extends DAXClient {
+}
+smithyClient.createAggregatedClient(commands, DAX);
-// 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 extends DAXClient {
-  static {
-    __name(this, "DAX");
-  }
-};
-(0, import_smithy_client.createAggregatedClient)(commands, DAX);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DAXServiceException,
-  __Client,
-  DAXClient,
-  DAX,
-  $Command,
-  CreateClusterCommand,
-  CreateParameterGroupCommand,
-  CreateSubnetGroupCommand,
-  DecreaseReplicationFactorCommand,
-  DeleteClusterCommand,
-  DeleteParameterGroupCommand,
-  DeleteSubnetGroupCommand,
-  DescribeClustersCommand,
-  DescribeDefaultParametersCommand,
-  DescribeEventsCommand,
-  DescribeParameterGroupsCommand,
-  DescribeParametersCommand,
-  DescribeSubnetGroupsCommand,
-  IncreaseReplicationFactorCommand,
-  ListTagsCommand,
-  RebootNodeCommand,
-  TagResourceCommand,
-  UntagResourceCommand,
-  UpdateClusterCommand,
-  UpdateParameterGroupCommand,
-  UpdateSubnetGroupCommand,
-  ClusterAlreadyExistsFault,
-  ClusterQuotaForCustomerExceededFault,
-  ClusterEndpointEncryptionType,
-  NetworkType,
-  SSEStatus,
-  InsufficientClusterCapacityFault,
-  InvalidClusterStateFault,
-  InvalidParameterCombinationException,
-  InvalidParameterGroupStateFault,
-  InvalidParameterValueException,
-  InvalidVPCNetworkStateFault,
-  NodeQuotaForClusterExceededFault,
-  NodeQuotaForCustomerExceededFault,
-  ParameterGroupNotFoundFault,
-  ServiceLinkedRoleNotFoundFault,
-  ServiceQuotaExceededException,
-  SubnetGroupNotFoundFault,
-  TagQuotaPerResourceExceeded,
-  ParameterGroupAlreadyExistsFault,
-  ParameterGroupQuotaExceededFault,
-  InvalidSubnet,
-  SubnetGroupAlreadyExistsFault,
-  SubnetGroupQuotaExceededFault,
-  SubnetNotAllowedFault,
-  SubnetQuotaExceededFault,
-  ClusterNotFoundFault,
-  NodeNotFoundFault,
-  SubnetGroupInUseFault,
-  ChangeType,
-  IsModifiable,
-  ParameterType,
-  SourceType,
-  InvalidARNFault,
-  TagNotFoundFault,
-  SubnetInUse
+Object.defineProperty(exports, "$Command", {
+    enumerable: true,
+    get: function () { return smithyClient.Command; }
 });
+Object.defineProperty(exports, "__Client", {
+    enumerable: true,
+    get: function () { return smithyClient.Client; }
+});
+exports.ChangeType = ChangeType;
+exports.ClusterAlreadyExistsFault = ClusterAlreadyExistsFault;
+exports.ClusterEndpointEncryptionType = ClusterEndpointEncryptionType;
+exports.ClusterNotFoundFault = ClusterNotFoundFault;
+exports.ClusterQuotaForCustomerExceededFault = ClusterQuotaForCustomerExceededFault;
+exports.CreateClusterCommand = CreateClusterCommand;
+exports.CreateParameterGroupCommand = CreateParameterGroupCommand;
+exports.CreateSubnetGroupCommand = CreateSubnetGroupCommand;
+exports.DAX = DAX;
+exports.DAXClient = DAXClient;
+exports.DAXServiceException = DAXServiceException;
+exports.DecreaseReplicationFactorCommand = DecreaseReplicationFactorCommand;
+exports.DeleteClusterCommand = DeleteClusterCommand;
+exports.DeleteParameterGroupCommand = DeleteParameterGroupCommand;
+exports.DeleteSubnetGroupCommand = DeleteSubnetGroupCommand;
+exports.DescribeClustersCommand = DescribeClustersCommand;
+exports.DescribeDefaultParametersCommand = DescribeDefaultParametersCommand;
+exports.DescribeEventsCommand = DescribeEventsCommand;
+exports.DescribeParameterGroupsCommand = DescribeParameterGroupsCommand;
+exports.DescribeParametersCommand = DescribeParametersCommand;
+exports.DescribeSubnetGroupsCommand = DescribeSubnetGroupsCommand;
+exports.IncreaseReplicationFactorCommand = IncreaseReplicationFactorCommand;
+exports.InsufficientClusterCapacityFault = InsufficientClusterCapacityFault;
+exports.InvalidARNFault = InvalidARNFault;
+exports.InvalidClusterStateFault = InvalidClusterStateFault;
+exports.InvalidParameterCombinationException = InvalidParameterCombinationException;
+exports.InvalidParameterGroupStateFault = InvalidParameterGroupStateFault;
+exports.InvalidParameterValueException = InvalidParameterValueException;
+exports.InvalidSubnet = InvalidSubnet;
+exports.InvalidVPCNetworkStateFault = InvalidVPCNetworkStateFault;
+exports.IsModifiable = IsModifiable;
+exports.ListTagsCommand = ListTagsCommand;
+exports.NetworkType = NetworkType;
+exports.NodeNotFoundFault = NodeNotFoundFault;
+exports.NodeQuotaForClusterExceededFault = NodeQuotaForClusterExceededFault;
+exports.NodeQuotaForCustomerExceededFault = NodeQuotaForCustomerExceededFault;
+exports.ParameterGroupAlreadyExistsFault = ParameterGroupAlreadyExistsFault;
+exports.ParameterGroupNotFoundFault = ParameterGroupNotFoundFault;
+exports.ParameterGroupQuotaExceededFault = ParameterGroupQuotaExceededFault;
+exports.ParameterType = ParameterType;
+exports.RebootNodeCommand = RebootNodeCommand;
+exports.SSEStatus = SSEStatus;
+exports.ServiceLinkedRoleNotFoundFault = ServiceLinkedRoleNotFoundFault;
+exports.ServiceQuotaExceededException = ServiceQuotaExceededException;
+exports.SourceType = SourceType;
+exports.SubnetGroupAlreadyExistsFault = SubnetGroupAlreadyExistsFault;
+exports.SubnetGroupInUseFault = SubnetGroupInUseFault;
+exports.SubnetGroupNotFoundFault = SubnetGroupNotFoundFault;
+exports.SubnetGroupQuotaExceededFault = SubnetGroupQuotaExceededFault;
+exports.SubnetInUse = SubnetInUse;
+exports.SubnetNotAllowedFault = SubnetNotAllowedFault;
+exports.SubnetQuotaExceededFault = SubnetQuotaExceededFault;
+exports.TagNotFoundFault = TagNotFoundFault;
+exports.TagQuotaPerResourceExceeded = TagQuotaPerResourceExceeded;
+exports.TagResourceCommand = TagResourceCommand;
+exports.UntagResourceCommand = UntagResourceCommand;
+exports.UpdateClusterCommand = UpdateClusterCommand;
+exports.UpdateParameterGroupCommand = UpdateParameterGroupCommand;
+exports.UpdateSubnetGroupCommand = UpdateSubnetGroupCommand;