@aws-sdk/client-cloudcontrol 3.901.0 → 3.907.0

package/dist-cjs/index.js

@@ -1,1566 +1,1319 @@
-"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);
+'use strict';
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AlreadyExistsException: () => AlreadyExistsException,
-  CancelResourceRequestCommand: () => CancelResourceRequestCommand,
-  CancelResourceRequestOutputFilterSensitiveLog: () => CancelResourceRequestOutputFilterSensitiveLog,
-  ClientTokenConflictException: () => ClientTokenConflictException,
-  CloudControl: () => CloudControl,
-  CloudControlClient: () => CloudControlClient,
-  CloudControlServiceException: () => CloudControlServiceException,
-  ConcurrentModificationException: () => ConcurrentModificationException,
-  ConcurrentOperationException: () => ConcurrentOperationException,
-  CreateResourceCommand: () => CreateResourceCommand,
-  CreateResourceInputFilterSensitiveLog: () => CreateResourceInputFilterSensitiveLog,
-  CreateResourceOutputFilterSensitiveLog: () => CreateResourceOutputFilterSensitiveLog,
-  DeleteResourceCommand: () => DeleteResourceCommand,
-  DeleteResourceOutputFilterSensitiveLog: () => DeleteResourceOutputFilterSensitiveLog,
-  GeneralServiceException: () => GeneralServiceException,
-  GetResourceCommand: () => GetResourceCommand,
-  GetResourceOutputFilterSensitiveLog: () => GetResourceOutputFilterSensitiveLog,
-  GetResourceRequestStatusCommand: () => GetResourceRequestStatusCommand,
-  GetResourceRequestStatusOutputFilterSensitiveLog: () => GetResourceRequestStatusOutputFilterSensitiveLog,
-  HandlerErrorCode: () => HandlerErrorCode,
-  HandlerFailureException: () => HandlerFailureException,
-  HandlerInternalFailureException: () => HandlerInternalFailureException,
-  InvalidCredentialsException: () => InvalidCredentialsException,
-  InvalidRequestException: () => InvalidRequestException,
-  ListResourceRequestsCommand: () => ListResourceRequestsCommand,
-  ListResourceRequestsOutputFilterSensitiveLog: () => ListResourceRequestsOutputFilterSensitiveLog,
-  ListResourcesCommand: () => ListResourcesCommand,
-  ListResourcesInputFilterSensitiveLog: () => ListResourcesInputFilterSensitiveLog,
-  ListResourcesOutputFilterSensitiveLog: () => ListResourcesOutputFilterSensitiveLog,
-  NetworkFailureException: () => NetworkFailureException,
-  NotStabilizedException: () => NotStabilizedException,
-  NotUpdatableException: () => NotUpdatableException,
-  Operation: () => Operation,
-  OperationStatus: () => OperationStatus,
-  PrivateTypeException: () => PrivateTypeException,
-  ProgressEventFilterSensitiveLog: () => ProgressEventFilterSensitiveLog,
-  RequestTokenNotFoundException: () => RequestTokenNotFoundException,
-  ResourceConflictException: () => ResourceConflictException,
-  ResourceDescriptionFilterSensitiveLog: () => ResourceDescriptionFilterSensitiveLog,
-  ResourceNotFoundException: () => ResourceNotFoundException,
-  ServiceInternalErrorException: () => ServiceInternalErrorException,
-  ServiceLimitExceededException: () => ServiceLimitExceededException,
-  ThrottlingException: () => ThrottlingException,
-  TypeNotFoundException: () => TypeNotFoundException,
-  UnsupportedActionException: () => UnsupportedActionException,
-  UpdateResourceCommand: () => UpdateResourceCommand,
-  UpdateResourceInputFilterSensitiveLog: () => UpdateResourceInputFilterSensitiveLog,
-  UpdateResourceOutputFilterSensitiveLog: () => UpdateResourceOutputFilterSensitiveLog,
-  __Client: () => import_smithy_client.Client,
-  paginateListResourceRequests: () => paginateListResourceRequests,
-  paginateListResources: () => paginateListResources,
-  waitForResourceRequestSuccess: () => waitForResourceRequestSuccess,
-  waitUntilResourceRequestSuccess: () => waitUntilResourceRequestSuccess
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/CloudControlClient.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 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');
+var uuid = require('@smithy/uuid');
+var utilWaiter = require('@smithy/util-waiter');
 
-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: "cloudcontrolapi"
-  });
-}, "resolveClientEndpointParameters");
-var commonParams = {
-  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
-  Endpoint: { type: "builtInParams", name: "endpoint" },
-  Region: { type: "builtInParams", name: "region" },
-  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+const resolveClientEndpointParameters = (options) => {
+    return Object.assign(options, {
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "cloudcontrolapi",
+    });
+};
+const commonParams = {
+    UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+    Endpoint: { type: "builtInParams", name: "endpoint" },
+    Region: { type: "builtInParams", name: "region" },
+    UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
-// src/CloudControlClient.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 CloudControlClient 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.defaultCloudControlHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new core.DefaultIdentityProviderConfig({
+                "aws.auth#sigv4": config.credentials,
+            }),
+        }));
+        this.middlewareStack.use(core.getHttpSigningPlugin(this.config));
+    }
+    destroy() {
+        super.destroy();
     }
-  };
-}, "getHttpAuthExtensionConfiguration");
-var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
-  return {
-    httpAuthSchemes: config.httpAuthSchemes(),
-    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
-    credentials: config.credentials()
-  };
-}, "resolveHttpAuthRuntimeConfig");
+}
 
-// 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 CloudControlServiceException extends smithyClient.ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, CloudControlServiceException.prototype);
+    }
+}
 
-// src/CloudControlClient.ts
-var CloudControlClient = class extends import_smithy_client.Client {
-  static {
-    __name(this, "CloudControlClient");
-  }
-  /**
-   * The resolved configuration of CloudControlClient class. This is resolved and normalized from the {@link CloudControlClientConfig | 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.defaultCloudControlHttpAuthSchemeParametersProvider,
-        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 AlreadyExistsException extends CloudControlServiceException {
+    name = "AlreadyExistsException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "AlreadyExistsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, AlreadyExistsException.prototype);
+        this.Message = opts.Message;
+    }
+}
+const HandlerErrorCode = {
+    ACCESS_DENIED: "AccessDenied",
+    ALREADY_EXISTS: "AlreadyExists",
+    GENERAL_SERVICE_EXCEPTION: "GeneralServiceException",
+    INTERNAL_FAILURE: "InternalFailure",
+    INVALID_CREDENTIALS: "InvalidCredentials",
+    INVALID_REQUEST: "InvalidRequest",
+    NETWORK_FAILURE: "NetworkFailure",
+    NOT_FOUND: "NotFound",
+    NOT_STABILIZED: "NotStabilized",
+    NOT_UPDATABLE: "NotUpdatable",
+    RESOURCE_CONFLICT: "ResourceConflict",
+    SERVICE_INTERNAL_ERROR: "ServiceInternalError",
+    SERVICE_LIMIT_EXCEEDED: "ServiceLimitExceeded",
+    SERVICE_TIMEOUT: "ServiceTimeout",
+    THROTTLING: "Throttling",
+    UNAUTHORIZED_TAGGING_OPERATION: "UnauthorizedTaggingOperation",
 };
-
-// src/CloudControl.ts
-
-
-// src/commands/CancelResourceRequestCommand.ts
-
-var import_middleware_serde = require("@smithy/middleware-serde");
-
-
-// src/models/models_0.ts
-
-
-// src/models/CloudControlServiceException.ts
-
-var CloudControlServiceException = class _CloudControlServiceException extends import_smithy_client.ServiceException {
-  static {
-    __name(this, "CloudControlServiceException");
-  }
-  /**
-   * @internal
-   */
-  constructor(options) {
-    super(options);
-    Object.setPrototypeOf(this, _CloudControlServiceException.prototype);
-  }
+const Operation = {
+    CREATE: "CREATE",
+    DELETE: "DELETE",
+    UPDATE: "UPDATE",
+};
+const OperationStatus = {
+    CANCEL_COMPLETE: "CANCEL_COMPLETE",
+    CANCEL_IN_PROGRESS: "CANCEL_IN_PROGRESS",
+    FAILED: "FAILED",
+    IN_PROGRESS: "IN_PROGRESS",
+    PENDING: "PENDING",
+    SUCCESS: "SUCCESS",
 };
+class ConcurrentModificationException extends CloudControlServiceException {
+    name = "ConcurrentModificationException";
+    $fault = "server";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ConcurrentModificationException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConcurrentModificationException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class RequestTokenNotFoundException extends CloudControlServiceException {
+    name = "RequestTokenNotFoundException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "RequestTokenNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, RequestTokenNotFoundException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ClientTokenConflictException extends CloudControlServiceException {
+    name = "ClientTokenConflictException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ClientTokenConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ClientTokenConflictException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ConcurrentOperationException extends CloudControlServiceException {
+    name = "ConcurrentOperationException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ConcurrentOperationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConcurrentOperationException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class GeneralServiceException extends CloudControlServiceException {
+    name = "GeneralServiceException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "GeneralServiceException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, GeneralServiceException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class HandlerFailureException extends CloudControlServiceException {
+    name = "HandlerFailureException";
+    $fault = "server";
+    Message;
+    constructor(opts) {
+        super({
+            name: "HandlerFailureException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, HandlerFailureException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class HandlerInternalFailureException extends CloudControlServiceException {
+    name = "HandlerInternalFailureException";
+    $fault = "server";
+    Message;
+    constructor(opts) {
+        super({
+            name: "HandlerInternalFailureException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, HandlerInternalFailureException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class InvalidCredentialsException extends CloudControlServiceException {
+    name = "InvalidCredentialsException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "InvalidCredentialsException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidCredentialsException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class InvalidRequestException extends CloudControlServiceException {
+    name = "InvalidRequestException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "InvalidRequestException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidRequestException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class NetworkFailureException extends CloudControlServiceException {
+    name = "NetworkFailureException";
+    $fault = "server";
+    Message;
+    constructor(opts) {
+        super({
+            name: "NetworkFailureException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NetworkFailureException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class NotStabilizedException extends CloudControlServiceException {
+    name = "NotStabilizedException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "NotStabilizedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NotStabilizedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class NotUpdatableException extends CloudControlServiceException {
+    name = "NotUpdatableException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "NotUpdatableException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, NotUpdatableException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class PrivateTypeException extends CloudControlServiceException {
+    name = "PrivateTypeException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "PrivateTypeException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, PrivateTypeException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ResourceConflictException extends CloudControlServiceException {
+    name = "ResourceConflictException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ResourceConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceConflictException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ResourceNotFoundException extends CloudControlServiceException {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ServiceInternalErrorException extends CloudControlServiceException {
+    name = "ServiceInternalErrorException";
+    $fault = "server";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ServiceInternalErrorException",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceInternalErrorException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ServiceLimitExceededException extends CloudControlServiceException {
+    name = "ServiceLimitExceededException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ServiceLimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ServiceLimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ThrottlingException extends CloudControlServiceException {
+    name = "ThrottlingException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class TypeNotFoundException extends CloudControlServiceException {
+    name = "TypeNotFoundException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "TypeNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, TypeNotFoundException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class UnsupportedActionException extends CloudControlServiceException {
+    name = "UnsupportedActionException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "UnsupportedActionException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, UnsupportedActionException.prototype);
+        this.Message = opts.Message;
+    }
+}
+const ProgressEventFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ResourceModel && { ResourceModel: smithyClient.SENSITIVE_STRING }),
+});
+const CancelResourceRequestOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ProgressEvent && { ProgressEvent: ProgressEventFilterSensitiveLog(obj.ProgressEvent) }),
+});
+const CreateResourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.DesiredState && { DesiredState: smithyClient.SENSITIVE_STRING }),
+});
+const CreateResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ProgressEvent && { ProgressEvent: ProgressEventFilterSensitiveLog(obj.ProgressEvent) }),
+});
+const DeleteResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ProgressEvent && { ProgressEvent: ProgressEventFilterSensitiveLog(obj.ProgressEvent) }),
+});
+const ResourceDescriptionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.Properties && { Properties: smithyClient.SENSITIVE_STRING }),
+});
+const GetResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ResourceDescription && {
+        ResourceDescription: ResourceDescriptionFilterSensitiveLog(obj.ResourceDescription),
+    }),
+});
+const GetResourceRequestStatusOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ProgressEvent && { ProgressEvent: ProgressEventFilterSensitiveLog(obj.ProgressEvent) }),
+});
+const ListResourceRequestsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ResourceRequestStatusSummaries && {
+        ResourceRequestStatusSummaries: obj.ResourceRequestStatusSummaries.map((item) => ProgressEventFilterSensitiveLog(item)),
+    }),
+});
+const ListResourcesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ResourceModel && { ResourceModel: smithyClient.SENSITIVE_STRING }),
+});
+const ListResourcesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ResourceDescriptions && {
+        ResourceDescriptions: obj.ResourceDescriptions.map((item) => ResourceDescriptionFilterSensitiveLog(item)),
+    }),
+});
+const UpdateResourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.PatchDocument && { PatchDocument: smithyClient.SENSITIVE_STRING }),
+});
+const UpdateResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.ProgressEvent && { ProgressEvent: ProgressEventFilterSensitiveLog(obj.ProgressEvent) }),
+});
 
-// src/models/models_0.ts
-var AlreadyExistsException = class _AlreadyExistsException extends CloudControlServiceException {
-  static {
-    __name(this, "AlreadyExistsException");
-  }
-  name = "AlreadyExistsException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "AlreadyExistsException",
-      $fault: "client",
-      ...opts
+const se_CancelResourceRequestCommand = async (input, context) => {
+    const headers = sharedHeaders("CancelResourceRequest");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_CreateResourceCommand = async (input, context) => {
+    const headers = sharedHeaders("CreateResource");
+    let body;
+    body = JSON.stringify(se_CreateResourceInput(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_DeleteResourceCommand = async (input, context) => {
+    const headers = sharedHeaders("DeleteResource");
+    let body;
+    body = JSON.stringify(se_DeleteResourceInput(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetResourceCommand = async (input, context) => {
+    const headers = sharedHeaders("GetResource");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_GetResourceRequestStatusCommand = async (input, context) => {
+    const headers = sharedHeaders("GetResourceRequestStatus");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListResourceRequestsCommand = async (input, context) => {
+    const headers = sharedHeaders("ListResourceRequests");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_ListResourcesCommand = async (input, context) => {
+    const headers = sharedHeaders("ListResources");
+    let body;
+    body = JSON.stringify(smithyClient._json(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const se_UpdateResourceCommand = async (input, context) => {
+    const headers = sharedHeaders("UpdateResource");
+    let body;
+    body = JSON.stringify(se_UpdateResourceInput(input));
+    return buildHttpRpcRequest(context, headers, "/", undefined, body);
+};
+const de_CancelResourceRequestCommand = 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_CancelResourceRequestOutput(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_CreateResourceCommand = 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_CreateResourceOutput(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_DeleteResourceCommand = 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_DeleteResourceOutput(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_GetResourceCommand = 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_GetResourceRequestStatusCommand = 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_GetResourceRequestStatusOutput(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListResourceRequestsCommand = 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_ListResourceRequestsOutput(data);
+    const response = {
+        $metadata: deserializeMetadata(output),
+        ...contents,
+    };
+    return response;
+};
+const de_ListResourcesCommand = 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_UpdateResourceCommand = 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_UpdateResourceOutput(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 "ConcurrentModificationException":
+        case "com.amazonaws.cloudcontrol#ConcurrentModificationException":
+            throw await de_ConcurrentModificationExceptionRes(parsedOutput);
+        case "RequestTokenNotFoundException":
+        case "com.amazonaws.cloudcontrol#RequestTokenNotFoundException":
+            throw await de_RequestTokenNotFoundExceptionRes(parsedOutput);
+        case "AlreadyExistsException":
+        case "com.amazonaws.cloudcontrol#AlreadyExistsException":
+            throw await de_AlreadyExistsExceptionRes(parsedOutput);
+        case "ClientTokenConflictException":
+        case "com.amazonaws.cloudcontrol#ClientTokenConflictException":
+            throw await de_ClientTokenConflictExceptionRes(parsedOutput);
+        case "ConcurrentOperationException":
+        case "com.amazonaws.cloudcontrol#ConcurrentOperationException":
+            throw await de_ConcurrentOperationExceptionRes(parsedOutput);
+        case "GeneralServiceException":
+        case "com.amazonaws.cloudcontrol#GeneralServiceException":
+            throw await de_GeneralServiceExceptionRes(parsedOutput);
+        case "HandlerFailureException":
+        case "com.amazonaws.cloudcontrol#HandlerFailureException":
+            throw await de_HandlerFailureExceptionRes(parsedOutput);
+        case "HandlerInternalFailureException":
+        case "com.amazonaws.cloudcontrol#HandlerInternalFailureException":
+            throw await de_HandlerInternalFailureExceptionRes(parsedOutput);
+        case "InvalidCredentialsException":
+        case "com.amazonaws.cloudcontrol#InvalidCredentialsException":
+            throw await de_InvalidCredentialsExceptionRes(parsedOutput);
+        case "InvalidRequestException":
+        case "com.amazonaws.cloudcontrol#InvalidRequestException":
+            throw await de_InvalidRequestExceptionRes(parsedOutput);
+        case "NetworkFailureException":
+        case "com.amazonaws.cloudcontrol#NetworkFailureException":
+            throw await de_NetworkFailureExceptionRes(parsedOutput);
+        case "NotStabilizedException":
+        case "com.amazonaws.cloudcontrol#NotStabilizedException":
+            throw await de_NotStabilizedExceptionRes(parsedOutput);
+        case "NotUpdatableException":
+        case "com.amazonaws.cloudcontrol#NotUpdatableException":
+            throw await de_NotUpdatableExceptionRes(parsedOutput);
+        case "PrivateTypeException":
+        case "com.amazonaws.cloudcontrol#PrivateTypeException":
+            throw await de_PrivateTypeExceptionRes(parsedOutput);
+        case "ResourceConflictException":
+        case "com.amazonaws.cloudcontrol#ResourceConflictException":
+            throw await de_ResourceConflictExceptionRes(parsedOutput);
+        case "ResourceNotFoundException":
+        case "com.amazonaws.cloudcontrol#ResourceNotFoundException":
+            throw await de_ResourceNotFoundExceptionRes(parsedOutput);
+        case "ServiceInternalErrorException":
+        case "com.amazonaws.cloudcontrol#ServiceInternalErrorException":
+            throw await de_ServiceInternalErrorExceptionRes(parsedOutput);
+        case "ServiceLimitExceededException":
+        case "com.amazonaws.cloudcontrol#ServiceLimitExceededException":
+            throw await de_ServiceLimitExceededExceptionRes(parsedOutput);
+        case "ThrottlingException":
+        case "com.amazonaws.cloudcontrol#ThrottlingException":
+            throw await de_ThrottlingExceptionRes(parsedOutput);
+        case "TypeNotFoundException":
+        case "com.amazonaws.cloudcontrol#TypeNotFoundException":
+            throw await de_TypeNotFoundExceptionRes(parsedOutput);
+        case "UnsupportedActionException":
+        case "com.amazonaws.cloudcontrol#UnsupportedActionException":
+            throw await de_UnsupportedActionExceptionRes(parsedOutput);
+        default:
+            const parsedBody = parsedOutput.body;
+            return throwDefaultError({
+                output,
+                parsedBody,
+                errorCode,
+            });
+    }
+};
+const de_AlreadyExistsExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new AlreadyExistsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _AlreadyExistsException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var HandlerErrorCode = {
-  ACCESS_DENIED: "AccessDenied",
-  ALREADY_EXISTS: "AlreadyExists",
-  GENERAL_SERVICE_EXCEPTION: "GeneralServiceException",
-  INTERNAL_FAILURE: "InternalFailure",
-  INVALID_CREDENTIALS: "InvalidCredentials",
-  INVALID_REQUEST: "InvalidRequest",
-  NETWORK_FAILURE: "NetworkFailure",
-  NOT_FOUND: "NotFound",
-  NOT_STABILIZED: "NotStabilized",
-  NOT_UPDATABLE: "NotUpdatable",
-  RESOURCE_CONFLICT: "ResourceConflict",
-  SERVICE_INTERNAL_ERROR: "ServiceInternalError",
-  SERVICE_LIMIT_EXCEEDED: "ServiceLimitExceeded",
-  SERVICE_TIMEOUT: "ServiceTimeout",
-  THROTTLING: "Throttling",
-  UNAUTHORIZED_TAGGING_OPERATION: "UnauthorizedTaggingOperation"
-};
-var Operation = {
-  CREATE: "CREATE",
-  DELETE: "DELETE",
-  UPDATE: "UPDATE"
-};
-var OperationStatus = {
-  CANCEL_COMPLETE: "CANCEL_COMPLETE",
-  CANCEL_IN_PROGRESS: "CANCEL_IN_PROGRESS",
-  FAILED: "FAILED",
-  IN_PROGRESS: "IN_PROGRESS",
-  PENDING: "PENDING",
-  SUCCESS: "SUCCESS"
-};
-var ConcurrentModificationException = class _ConcurrentModificationException extends CloudControlServiceException {
-  static {
-    __name(this, "ConcurrentModificationException");
-  }
-  name = "ConcurrentModificationException";
-  $fault = "server";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ConcurrentModificationException",
-      $fault: "server",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ClientTokenConflictExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ClientTokenConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ConcurrentModificationException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var RequestTokenNotFoundException = class _RequestTokenNotFoundException extends CloudControlServiceException {
-  static {
-    __name(this, "RequestTokenNotFoundException");
-  }
-  name = "RequestTokenNotFoundException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "RequestTokenNotFoundException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ConcurrentModificationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ConcurrentModificationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _RequestTokenNotFoundException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var ClientTokenConflictException = class _ClientTokenConflictException extends CloudControlServiceException {
-  static {
-    __name(this, "ClientTokenConflictException");
-  }
-  name = "ClientTokenConflictException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ClientTokenConflictException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ConcurrentOperationExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ConcurrentOperationException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ClientTokenConflictException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var ConcurrentOperationException = class _ConcurrentOperationException extends CloudControlServiceException {
-  static {
-    __name(this, "ConcurrentOperationException");
-  }
-  name = "ConcurrentOperationException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ConcurrentOperationException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_GeneralServiceExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new GeneralServiceException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ConcurrentOperationException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var GeneralServiceException = class _GeneralServiceException extends CloudControlServiceException {
-  static {
-    __name(this, "GeneralServiceException");
-  }
-  name = "GeneralServiceException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "GeneralServiceException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_HandlerFailureExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new HandlerFailureException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _GeneralServiceException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var HandlerFailureException = class _HandlerFailureException extends CloudControlServiceException {
-  static {
-    __name(this, "HandlerFailureException");
-  }
-  name = "HandlerFailureException";
-  $fault = "server";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "HandlerFailureException",
-      $fault: "server",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_HandlerInternalFailureExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new HandlerInternalFailureException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _HandlerFailureException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var HandlerInternalFailureException = class _HandlerInternalFailureException extends CloudControlServiceException {
-  static {
-    __name(this, "HandlerInternalFailureException");
-  }
-  name = "HandlerInternalFailureException";
-  $fault = "server";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "HandlerInternalFailureException",
-      $fault: "server",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidCredentialsExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidCredentialsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _HandlerInternalFailureException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var InvalidCredentialsException = class _InvalidCredentialsException extends CloudControlServiceException {
-  static {
-    __name(this, "InvalidCredentialsException");
-  }
-  name = "InvalidCredentialsException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidCredentialsException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new InvalidRequestException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidCredentialsException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var InvalidRequestException = class _InvalidRequestException extends CloudControlServiceException {
-  static {
-    __name(this, "InvalidRequestException");
-  }
-  name = "InvalidRequestException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "InvalidRequestException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_NetworkFailureExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new NetworkFailureException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _InvalidRequestException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var NetworkFailureException = class _NetworkFailureException extends CloudControlServiceException {
-  static {
-    __name(this, "NetworkFailureException");
-  }
-  name = "NetworkFailureException";
-  $fault = "server";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "NetworkFailureException",
-      $fault: "server",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_NotStabilizedExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new NotStabilizedException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _NetworkFailureException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var NotStabilizedException = class _NotStabilizedException extends CloudControlServiceException {
-  static {
-    __name(this, "NotStabilizedException");
-  }
-  name = "NotStabilizedException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "NotStabilizedException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_NotUpdatableExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new NotUpdatableException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _NotStabilizedException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var NotUpdatableException = class _NotUpdatableException extends CloudControlServiceException {
-  static {
-    __name(this, "NotUpdatableException");
-  }
-  name = "NotUpdatableException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "NotUpdatableException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_PrivateTypeExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new PrivateTypeException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _NotUpdatableException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var PrivateTypeException = class _PrivateTypeException extends CloudControlServiceException {
-  static {
-    __name(this, "PrivateTypeException");
-  }
-  name = "PrivateTypeException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "PrivateTypeException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_RequestTokenNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new RequestTokenNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _PrivateTypeException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var ResourceConflictException = class _ResourceConflictException extends CloudControlServiceException {
-  static {
-    __name(this, "ResourceConflictException");
-  }
-  name = "ResourceConflictException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ResourceConflictException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ResourceConflictExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ResourceConflictException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ResourceConflictException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var ResourceNotFoundException = class _ResourceNotFoundException extends CloudControlServiceException {
-  static {
-    __name(this, "ResourceNotFoundException");
-  }
-  name = "ResourceNotFoundException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ResourceNotFoundException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ResourceNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var ServiceInternalErrorException = class _ServiceInternalErrorException extends CloudControlServiceException {
-  static {
-    __name(this, "ServiceInternalErrorException");
-  }
-  name = "ServiceInternalErrorException";
-  $fault = "server";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ServiceInternalErrorException",
-      $fault: "server",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ServiceInternalErrorExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ServiceInternalErrorException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ServiceInternalErrorException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var ServiceLimitExceededException = class _ServiceLimitExceededException extends CloudControlServiceException {
-  static {
-    __name(this, "ServiceLimitExceededException");
-  }
-  name = "ServiceLimitExceededException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ServiceLimitExceededException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ServiceLimitExceededExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ServiceLimitExceededException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ServiceLimitExceededException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var ThrottlingException = class _ThrottlingException extends CloudControlServiceException {
-  static {
-    __name(this, "ThrottlingException");
-  }
-  name = "ThrottlingException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "ThrottlingException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new ThrottlingException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _ThrottlingException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var TypeNotFoundException = class _TypeNotFoundException extends CloudControlServiceException {
-  static {
-    __name(this, "TypeNotFoundException");
-  }
-  name = "TypeNotFoundException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "TypeNotFoundException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_TypeNotFoundExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new TypeNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _TypeNotFoundException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var UnsupportedActionException = class _UnsupportedActionException extends CloudControlServiceException {
-  static {
-    __name(this, "UnsupportedActionException");
-  }
-  name = "UnsupportedActionException";
-  $fault = "client";
-  Message;
-  /**
-   * @internal
-   */
-  constructor(opts) {
-    super({
-      name: "UnsupportedActionException",
-      $fault: "client",
-      ...opts
+    return smithyClient.decorateServiceException(exception, body);
+};
+const de_UnsupportedActionExceptionRes = async (parsedOutput, context) => {
+    const body = parsedOutput.body;
+    const deserialized = smithyClient._json(body);
+    const exception = new UnsupportedActionException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...deserialized,
     });
-    Object.setPrototypeOf(this, _UnsupportedActionException.prototype);
-    this.Message = opts.Message;
-  }
-};
-var ProgressEventFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.ResourceModel && { ResourceModel: import_smithy_client.SENSITIVE_STRING }
-}), "ProgressEventFilterSensitiveLog");
-var CancelResourceRequestOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.ProgressEvent && { ProgressEvent: ProgressEventFilterSensitiveLog(obj.ProgressEvent) }
-}), "CancelResourceRequestOutputFilterSensitiveLog");
-var CreateResourceInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.DesiredState && { DesiredState: import_smithy_client.SENSITIVE_STRING }
-}), "CreateResourceInputFilterSensitiveLog");
-var CreateResourceOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.ProgressEvent && { ProgressEvent: ProgressEventFilterSensitiveLog(obj.ProgressEvent) }
-}), "CreateResourceOutputFilterSensitiveLog");
-var DeleteResourceOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.ProgressEvent && { ProgressEvent: ProgressEventFilterSensitiveLog(obj.ProgressEvent) }
-}), "DeleteResourceOutputFilterSensitiveLog");
-var ResourceDescriptionFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.Properties && { Properties: import_smithy_client.SENSITIVE_STRING }
-}), "ResourceDescriptionFilterSensitiveLog");
-var GetResourceOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.ResourceDescription && {
-    ResourceDescription: ResourceDescriptionFilterSensitiveLog(obj.ResourceDescription)
-  }
-}), "GetResourceOutputFilterSensitiveLog");
-var GetResourceRequestStatusOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.ProgressEvent && { ProgressEvent: ProgressEventFilterSensitiveLog(obj.ProgressEvent) }
-}), "GetResourceRequestStatusOutputFilterSensitiveLog");
-var ListResourceRequestsOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.ResourceRequestStatusSummaries && {
-    ResourceRequestStatusSummaries: obj.ResourceRequestStatusSummaries.map(
-      (item) => ProgressEventFilterSensitiveLog(item)
-    )
-  }
-}), "ListResourceRequestsOutputFilterSensitiveLog");
-var ListResourcesInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.ResourceModel && { ResourceModel: import_smithy_client.SENSITIVE_STRING }
-}), "ListResourcesInputFilterSensitiveLog");
-var ListResourcesOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.ResourceDescriptions && {
-    ResourceDescriptions: obj.ResourceDescriptions.map((item) => ResourceDescriptionFilterSensitiveLog(item))
-  }
-}), "ListResourcesOutputFilterSensitiveLog");
-var UpdateResourceInputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.PatchDocument && { PatchDocument: import_smithy_client.SENSITIVE_STRING }
-}), "UpdateResourceInputFilterSensitiveLog");
-var UpdateResourceOutputFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj,
-  ...obj.ProgressEvent && { ProgressEvent: ProgressEventFilterSensitiveLog(obj.ProgressEvent) }
-}), "UpdateResourceOutputFilterSensitiveLog");
-
-// src/protocols/Aws_json1_0.ts
-var import_core2 = require("@aws-sdk/core");
-
-
-var import_uuid = require("@smithy/uuid");
-var se_CancelResourceRequestCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("CancelResourceRequest");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_CancelResourceRequestCommand");
-var se_CreateResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("CreateResource");
-  let body;
-  body = JSON.stringify(se_CreateResourceInput(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_CreateResourceCommand");
-var se_DeleteResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("DeleteResource");
-  let body;
-  body = JSON.stringify(se_DeleteResourceInput(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_DeleteResourceCommand");
-var se_GetResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("GetResource");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_GetResourceCommand");
-var se_GetResourceRequestStatusCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("GetResourceRequestStatus");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_GetResourceRequestStatusCommand");
-var se_ListResourceRequestsCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("ListResourceRequests");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_ListResourceRequestsCommand");
-var se_ListResourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("ListResources");
-  let body;
-  body = JSON.stringify((0, import_smithy_client._json)(input));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_ListResourcesCommand");
-var se_UpdateResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
-  const headers = sharedHeaders("UpdateResource");
-  let body;
-  body = JSON.stringify(se_UpdateResourceInput(input, context));
-  return buildHttpRpcRequest(context, headers, "/", void 0, body);
-}, "se_UpdateResourceCommand");
-var de_CancelResourceRequestCommand = /* @__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_CancelResourceRequestOutput(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CancelResourceRequestCommand");
-var de_CreateResourceCommand = /* @__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_CreateResourceOutput(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_CreateResourceCommand");
-var de_DeleteResourceCommand = /* @__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_DeleteResourceOutput(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_DeleteResourceCommand");
-var de_GetResourceCommand = /* @__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_GetResourceCommand");
-var de_GetResourceRequestStatusCommand = /* @__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_GetResourceRequestStatusOutput(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_GetResourceRequestStatusCommand");
-var de_ListResourceRequestsCommand = /* @__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_ListResourceRequestsOutput(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_ListResourceRequestsCommand");
-var de_ListResourcesCommand = /* @__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_ListResourcesCommand");
-var de_UpdateResourceCommand = /* @__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_UpdateResourceOutput(data, context);
-  const response = {
-    $metadata: deserializeMetadata(output),
-    ...contents
-  };
-  return response;
-}, "de_UpdateResourceCommand");
-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 "ConcurrentModificationException":
-    case "com.amazonaws.cloudcontrol#ConcurrentModificationException":
-      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
-    case "RequestTokenNotFoundException":
-    case "com.amazonaws.cloudcontrol#RequestTokenNotFoundException":
-      throw await de_RequestTokenNotFoundExceptionRes(parsedOutput, context);
-    case "AlreadyExistsException":
-    case "com.amazonaws.cloudcontrol#AlreadyExistsException":
-      throw await de_AlreadyExistsExceptionRes(parsedOutput, context);
-    case "ClientTokenConflictException":
-    case "com.amazonaws.cloudcontrol#ClientTokenConflictException":
-      throw await de_ClientTokenConflictExceptionRes(parsedOutput, context);
-    case "ConcurrentOperationException":
-    case "com.amazonaws.cloudcontrol#ConcurrentOperationException":
-      throw await de_ConcurrentOperationExceptionRes(parsedOutput, context);
-    case "GeneralServiceException":
-    case "com.amazonaws.cloudcontrol#GeneralServiceException":
-      throw await de_GeneralServiceExceptionRes(parsedOutput, context);
-    case "HandlerFailureException":
-    case "com.amazonaws.cloudcontrol#HandlerFailureException":
-      throw await de_HandlerFailureExceptionRes(parsedOutput, context);
-    case "HandlerInternalFailureException":
-    case "com.amazonaws.cloudcontrol#HandlerInternalFailureException":
-      throw await de_HandlerInternalFailureExceptionRes(parsedOutput, context);
-    case "InvalidCredentialsException":
-    case "com.amazonaws.cloudcontrol#InvalidCredentialsException":
-      throw await de_InvalidCredentialsExceptionRes(parsedOutput, context);
-    case "InvalidRequestException":
-    case "com.amazonaws.cloudcontrol#InvalidRequestException":
-      throw await de_InvalidRequestExceptionRes(parsedOutput, context);
-    case "NetworkFailureException":
-    case "com.amazonaws.cloudcontrol#NetworkFailureException":
-      throw await de_NetworkFailureExceptionRes(parsedOutput, context);
-    case "NotStabilizedException":
-    case "com.amazonaws.cloudcontrol#NotStabilizedException":
-      throw await de_NotStabilizedExceptionRes(parsedOutput, context);
-    case "NotUpdatableException":
-    case "com.amazonaws.cloudcontrol#NotUpdatableException":
-      throw await de_NotUpdatableExceptionRes(parsedOutput, context);
-    case "PrivateTypeException":
-    case "com.amazonaws.cloudcontrol#PrivateTypeException":
-      throw await de_PrivateTypeExceptionRes(parsedOutput, context);
-    case "ResourceConflictException":
-    case "com.amazonaws.cloudcontrol#ResourceConflictException":
-      throw await de_ResourceConflictExceptionRes(parsedOutput, context);
-    case "ResourceNotFoundException":
-    case "com.amazonaws.cloudcontrol#ResourceNotFoundException":
-      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
-    case "ServiceInternalErrorException":
-    case "com.amazonaws.cloudcontrol#ServiceInternalErrorException":
-      throw await de_ServiceInternalErrorExceptionRes(parsedOutput, context);
-    case "ServiceLimitExceededException":
-    case "com.amazonaws.cloudcontrol#ServiceLimitExceededException":
-      throw await de_ServiceLimitExceededExceptionRes(parsedOutput, context);
-    case "ThrottlingException":
-    case "com.amazonaws.cloudcontrol#ThrottlingException":
-      throw await de_ThrottlingExceptionRes(parsedOutput, context);
-    case "TypeNotFoundException":
-    case "com.amazonaws.cloudcontrol#TypeNotFoundException":
-      throw await de_TypeNotFoundExceptionRes(parsedOutput, context);
-    case "UnsupportedActionException":
-    case "com.amazonaws.cloudcontrol#UnsupportedActionException":
-      throw await de_UnsupportedActionExceptionRes(parsedOutput, context);
-    default:
-      const parsedBody = parsedOutput.body;
-      return throwDefaultError({
-        output,
-        parsedBody,
-        errorCode
-      });
-  }
-}, "de_CommandError");
-var de_AlreadyExistsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new AlreadyExistsException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_AlreadyExistsExceptionRes");
-var de_ClientTokenConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ClientTokenConflictException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ClientTokenConflictExceptionRes");
-var de_ConcurrentModificationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ConcurrentModificationException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ConcurrentModificationExceptionRes");
-var de_ConcurrentOperationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ConcurrentOperationException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ConcurrentOperationExceptionRes");
-var de_GeneralServiceExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new GeneralServiceException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_GeneralServiceExceptionRes");
-var de_HandlerFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new HandlerFailureException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_HandlerFailureExceptionRes");
-var de_HandlerInternalFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new HandlerInternalFailureException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_HandlerInternalFailureExceptionRes");
-var de_InvalidCredentialsExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new InvalidCredentialsException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_InvalidCredentialsExceptionRes");
-var de_InvalidRequestExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new InvalidRequestException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_InvalidRequestExceptionRes");
-var de_NetworkFailureExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new NetworkFailureException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_NetworkFailureExceptionRes");
-var de_NotStabilizedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new NotStabilizedException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_NotStabilizedExceptionRes");
-var de_NotUpdatableExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new NotUpdatableException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_NotUpdatableExceptionRes");
-var de_PrivateTypeExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new PrivateTypeException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_PrivateTypeExceptionRes");
-var de_RequestTokenNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new RequestTokenNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_RequestTokenNotFoundExceptionRes");
-var de_ResourceConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ResourceConflictException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ResourceConflictExceptionRes");
-var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ResourceNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ResourceNotFoundExceptionRes");
-var de_ServiceInternalErrorExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ServiceInternalErrorException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ServiceInternalErrorExceptionRes");
-var de_ServiceLimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ServiceLimitExceededException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ServiceLimitExceededExceptionRes");
-var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new ThrottlingException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_ThrottlingExceptionRes");
-var de_TypeNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new TypeNotFoundException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_TypeNotFoundExceptionRes");
-var de_UnsupportedActionExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
-  const body = parsedOutput.body;
-  const deserialized = (0, import_smithy_client._json)(body);
-  const exception = new UnsupportedActionException({
-    $metadata: deserializeMetadata(parsedOutput),
-    ...deserialized
-  });
-  return (0, import_smithy_client.decorateServiceException)(exception, body);
-}, "de_UnsupportedActionExceptionRes");
-var se_CreateResourceInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
-    DesiredState: [],
-    RoleArn: [],
-    TypeName: [],
-    TypeVersionId: []
-  });
-}, "se_CreateResourceInput");
-var se_DeleteResourceInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
-    Identifier: [],
-    RoleArn: [],
-    TypeName: [],
-    TypeVersionId: []
-  });
-}, "se_DeleteResourceInput");
-var se_UpdateResourceInput = /* @__PURE__ */ __name((input, context) => {
-  return (0, import_smithy_client.take)(input, {
-    ClientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
-    Identifier: [],
-    PatchDocument: [],
-    RoleArn: [],
-    TypeName: [],
-    TypeVersionId: []
-  });
-}, "se_UpdateResourceInput");
-var de_CancelResourceRequestOutput = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    ProgressEvent: /* @__PURE__ */ __name((_) => de_ProgressEvent(_, context), "ProgressEvent")
-  });
-}, "de_CancelResourceRequestOutput");
-var de_CreateResourceOutput = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    ProgressEvent: /* @__PURE__ */ __name((_) => de_ProgressEvent(_, context), "ProgressEvent")
-  });
-}, "de_CreateResourceOutput");
-var de_DeleteResourceOutput = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    ProgressEvent: /* @__PURE__ */ __name((_) => de_ProgressEvent(_, context), "ProgressEvent")
-  });
-}, "de_DeleteResourceOutput");
-var de_GetResourceRequestStatusOutput = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    HooksProgressEvent: /* @__PURE__ */ __name((_) => de_HooksProgressEvent(_, context), "HooksProgressEvent"),
-    ProgressEvent: /* @__PURE__ */ __name((_) => de_ProgressEvent(_, context), "ProgressEvent")
-  });
-}, "de_GetResourceRequestStatusOutput");
-var de_HookProgressEvent = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    FailureMode: import_smithy_client.expectString,
-    HookEventTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "HookEventTime"),
-    HookStatus: import_smithy_client.expectString,
-    HookStatusMessage: import_smithy_client.expectString,
-    HookTypeArn: import_smithy_client.expectString,
-    HookTypeName: import_smithy_client.expectString,
-    HookTypeVersionId: import_smithy_client.expectString,
-    InvocationPoint: import_smithy_client.expectString
-  });
-}, "de_HookProgressEvent");
-var de_HooksProgressEvent = /* @__PURE__ */ __name((output, context) => {
-  const retVal = (output || []).filter((e) => e != null).map((entry) => {
-    return de_HookProgressEvent(entry, context);
-  });
-  return retVal;
-}, "de_HooksProgressEvent");
-var de_ListResourceRequestsOutput = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    NextToken: import_smithy_client.expectString,
-    ResourceRequestStatusSummaries: /* @__PURE__ */ __name((_) => de_ResourceRequestStatusSummaries(_, context), "ResourceRequestStatusSummaries")
-  });
-}, "de_ListResourceRequestsOutput");
-var de_ProgressEvent = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    ErrorCode: import_smithy_client.expectString,
-    EventTime: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "EventTime"),
-    HooksRequestToken: import_smithy_client.expectString,
-    Identifier: import_smithy_client.expectString,
-    Operation: import_smithy_client.expectString,
-    OperationStatus: import_smithy_client.expectString,
-    RequestToken: import_smithy_client.expectString,
-    ResourceModel: import_smithy_client.expectString,
-    RetryAfter: /* @__PURE__ */ __name((_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))), "RetryAfter"),
-    StatusMessage: import_smithy_client.expectString,
-    TypeName: import_smithy_client.expectString
-  });
-}, "de_ProgressEvent");
-var de_ResourceRequestStatusSummaries = /* @__PURE__ */ __name((output, context) => {
-  const retVal = (output || []).filter((e) => e != null).map((entry) => {
-    return de_ProgressEvent(entry, context);
-  });
-  return retVal;
-}, "de_ResourceRequestStatusSummaries");
-var de_UpdateResourceOutput = /* @__PURE__ */ __name((output, context) => {
-  return (0, import_smithy_client.take)(output, {
-    ProgressEvent: /* @__PURE__ */ __name((_) => de_ProgressEvent(_, context), "ProgressEvent")
-  });
-}, "de_UpdateResourceOutput");
-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)(CloudControlServiceException);
-var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
-  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
-  const contents = {
-    protocol,
-    hostname,
-    port,
-    method: "POST",
-    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
-    headers
-  };
-  if (resolvedHostname !== void 0) {
-    contents.hostname = resolvedHostname;
-  }
-  if (body !== void 0) {
-    contents.body = body;
-  }
-  return new import_protocol_http.HttpRequest(contents);
-}, "buildHttpRpcRequest");
-function sharedHeaders(operation) {
-  return {
-    "content-type": "application/x-amz-json-1.0",
-    "x-amz-target": `CloudApiService.${operation}`
-  };
-}
-__name(sharedHeaders, "sharedHeaders");
-
-// src/commands/CancelResourceRequestCommand.ts
-var CancelResourceRequestCommand = 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("CloudApiService", "CancelResourceRequest", {}).n("CloudControlClient", "CancelResourceRequestCommand").f(void 0, CancelResourceRequestOutputFilterSensitiveLog).ser(se_CancelResourceRequestCommand).de(de_CancelResourceRequestCommand).build() {
-  static {
-    __name(this, "CancelResourceRequestCommand");
-  }
+    return smithyClient.decorateServiceException(exception, body);
 };
-
-// src/commands/CreateResourceCommand.ts
-
-
-
-var CreateResourceCommand = 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("CloudApiService", "CreateResource", {}).n("CloudControlClient", "CreateResourceCommand").f(CreateResourceInputFilterSensitiveLog, CreateResourceOutputFilterSensitiveLog).ser(se_CreateResourceCommand).de(de_CreateResourceCommand).build() {
-  static {
-    __name(this, "CreateResourceCommand");
-  }
+const se_CreateResourceInput = (input, context) => {
+    return smithyClient.take(input, {
+        ClientToken: [true, (_) => _ ?? uuid.v4()],
+        DesiredState: [],
+        RoleArn: [],
+        TypeName: [],
+        TypeVersionId: [],
+    });
 };
-
-// src/commands/DeleteResourceCommand.ts
-
-
-
-var DeleteResourceCommand = 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("CloudApiService", "DeleteResource", {}).n("CloudControlClient", "DeleteResourceCommand").f(void 0, DeleteResourceOutputFilterSensitiveLog).ser(se_DeleteResourceCommand).de(de_DeleteResourceCommand).build() {
-  static {
-    __name(this, "DeleteResourceCommand");
-  }
+const se_DeleteResourceInput = (input, context) => {
+    return smithyClient.take(input, {
+        ClientToken: [true, (_) => _ ?? uuid.v4()],
+        Identifier: [],
+        RoleArn: [],
+        TypeName: [],
+        TypeVersionId: [],
+    });
 };
-
-// src/commands/GetResourceCommand.ts
-
-
-
-var GetResourceCommand = 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("CloudApiService", "GetResource", {}).n("CloudControlClient", "GetResourceCommand").f(void 0, GetResourceOutputFilterSensitiveLog).ser(se_GetResourceCommand).de(de_GetResourceCommand).build() {
-  static {
-    __name(this, "GetResourceCommand");
-  }
+const se_UpdateResourceInput = (input, context) => {
+    return smithyClient.take(input, {
+        ClientToken: [true, (_) => _ ?? uuid.v4()],
+        Identifier: [],
+        PatchDocument: [],
+        RoleArn: [],
+        TypeName: [],
+        TypeVersionId: [],
+    });
 };
-
-// src/commands/GetResourceRequestStatusCommand.ts
-
-
-
-var GetResourceRequestStatusCommand = 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("CloudApiService", "GetResourceRequestStatus", {}).n("CloudControlClient", "GetResourceRequestStatusCommand").f(void 0, GetResourceRequestStatusOutputFilterSensitiveLog).ser(se_GetResourceRequestStatusCommand).de(de_GetResourceRequestStatusCommand).build() {
-  static {
-    __name(this, "GetResourceRequestStatusCommand");
-  }
+const de_CancelResourceRequestOutput = (output, context) => {
+    return smithyClient.take(output, {
+        ProgressEvent: (_) => de_ProgressEvent(_),
+    });
 };
-
-// src/commands/ListResourceRequestsCommand.ts
-
-
-
-var ListResourceRequestsCommand = 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("CloudApiService", "ListResourceRequests", {}).n("CloudControlClient", "ListResourceRequestsCommand").f(void 0, ListResourceRequestsOutputFilterSensitiveLog).ser(se_ListResourceRequestsCommand).de(de_ListResourceRequestsCommand).build() {
-  static {
-    __name(this, "ListResourceRequestsCommand");
-  }
+const de_CreateResourceOutput = (output, context) => {
+    return smithyClient.take(output, {
+        ProgressEvent: (_) => de_ProgressEvent(_),
+    });
 };
+const de_DeleteResourceOutput = (output, context) => {
+    return smithyClient.take(output, {
+        ProgressEvent: (_) => de_ProgressEvent(_),
+    });
+};
+const de_GetResourceRequestStatusOutput = (output, context) => {
+    return smithyClient.take(output, {
+        HooksProgressEvent: (_) => de_HooksProgressEvent(_),
+        ProgressEvent: (_) => de_ProgressEvent(_),
+    });
+};
+const de_HookProgressEvent = (output, context) => {
+    return smithyClient.take(output, {
+        FailureMode: smithyClient.expectString,
+        HookEventTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        HookStatus: smithyClient.expectString,
+        HookStatusMessage: smithyClient.expectString,
+        HookTypeArn: smithyClient.expectString,
+        HookTypeName: smithyClient.expectString,
+        HookTypeVersionId: smithyClient.expectString,
+        InvocationPoint: smithyClient.expectString,
+    });
+};
+const de_HooksProgressEvent = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_HookProgressEvent(entry);
+    });
+    return retVal;
+};
+const de_ListResourceRequestsOutput = (output, context) => {
+    return smithyClient.take(output, {
+        NextToken: smithyClient.expectString,
+        ResourceRequestStatusSummaries: (_) => de_ResourceRequestStatusSummaries(_),
+    });
+};
+const de_ProgressEvent = (output, context) => {
+    return smithyClient.take(output, {
+        ErrorCode: smithyClient.expectString,
+        EventTime: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        HooksRequestToken: smithyClient.expectString,
+        Identifier: smithyClient.expectString,
+        Operation: smithyClient.expectString,
+        OperationStatus: smithyClient.expectString,
+        RequestToken: smithyClient.expectString,
+        ResourceModel: smithyClient.expectString,
+        RetryAfter: (_) => smithyClient.expectNonNull(smithyClient.parseEpochTimestamp(smithyClient.expectNumber(_))),
+        StatusMessage: smithyClient.expectString,
+        TypeName: smithyClient.expectString,
+    });
+};
+const de_ResourceRequestStatusSummaries = (output, context) => {
+    const retVal = (output || [])
+        .filter((e) => e != null)
+        .map((entry) => {
+        return de_ProgressEvent(entry);
+    });
+    return retVal;
+};
+const de_UpdateResourceOutput = (output, context) => {
+    return smithyClient.take(output, {
+        ProgressEvent: (_) => de_ProgressEvent(_),
+    });
+};
+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(CloudControlServiceException);
+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.0",
+        "x-amz-target": `CloudApiService.${operation}`,
+    };
+}
 
-// src/commands/ListResourcesCommand.ts
-
-
+class CancelResourceRequestCommand 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("CloudApiService", "CancelResourceRequest", {})
+    .n("CloudControlClient", "CancelResourceRequestCommand")
+    .f(void 0, CancelResourceRequestOutputFilterSensitiveLog)
+    .ser(se_CancelResourceRequestCommand)
+    .de(de_CancelResourceRequestCommand)
+    .build() {
+}
 
-var ListResourcesCommand = 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("CloudApiService", "ListResources", {}).n("CloudControlClient", "ListResourcesCommand").f(ListResourcesInputFilterSensitiveLog, ListResourcesOutputFilterSensitiveLog).ser(se_ListResourcesCommand).de(de_ListResourcesCommand).build() {
-  static {
-    __name(this, "ListResourcesCommand");
-  }
-};
+class CreateResourceCommand 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("CloudApiService", "CreateResource", {})
+    .n("CloudControlClient", "CreateResourceCommand")
+    .f(CreateResourceInputFilterSensitiveLog, CreateResourceOutputFilterSensitiveLog)
+    .ser(se_CreateResourceCommand)
+    .de(de_CreateResourceCommand)
+    .build() {
+}
 
-// src/commands/UpdateResourceCommand.ts
+class DeleteResourceCommand 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("CloudApiService", "DeleteResource", {})
+    .n("CloudControlClient", "DeleteResourceCommand")
+    .f(void 0, DeleteResourceOutputFilterSensitiveLog)
+    .ser(se_DeleteResourceCommand)
+    .de(de_DeleteResourceCommand)
+    .build() {
+}
 
+class GetResourceCommand 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("CloudApiService", "GetResource", {})
+    .n("CloudControlClient", "GetResourceCommand")
+    .f(void 0, GetResourceOutputFilterSensitiveLog)
+    .ser(se_GetResourceCommand)
+    .de(de_GetResourceCommand)
+    .build() {
+}
 
+class GetResourceRequestStatusCommand 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("CloudApiService", "GetResourceRequestStatus", {})
+    .n("CloudControlClient", "GetResourceRequestStatusCommand")
+    .f(void 0, GetResourceRequestStatusOutputFilterSensitiveLog)
+    .ser(se_GetResourceRequestStatusCommand)
+    .de(de_GetResourceRequestStatusCommand)
+    .build() {
+}
 
-var UpdateResourceCommand = 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("CloudApiService", "UpdateResource", {}).n("CloudControlClient", "UpdateResourceCommand").f(UpdateResourceInputFilterSensitiveLog, UpdateResourceOutputFilterSensitiveLog).ser(se_UpdateResourceCommand).de(de_UpdateResourceCommand).build() {
-  static {
-    __name(this, "UpdateResourceCommand");
-  }
-};
+class ListResourceRequestsCommand 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("CloudApiService", "ListResourceRequests", {})
+    .n("CloudControlClient", "ListResourceRequestsCommand")
+    .f(void 0, ListResourceRequestsOutputFilterSensitiveLog)
+    .ser(se_ListResourceRequestsCommand)
+    .de(de_ListResourceRequestsCommand)
+    .build() {
+}
 
-// src/CloudControl.ts
-var commands = {
-  CancelResourceRequestCommand,
-  CreateResourceCommand,
-  DeleteResourceCommand,
-  GetResourceCommand,
-  GetResourceRequestStatusCommand,
-  ListResourceRequestsCommand,
-  ListResourcesCommand,
-  UpdateResourceCommand
-};
-var CloudControl = class extends CloudControlClient {
-  static {
-    __name(this, "CloudControl");
-  }
-};
-(0, import_smithy_client.createAggregatedClient)(commands, CloudControl);
+class ListResourcesCommand 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("CloudApiService", "ListResources", {})
+    .n("CloudControlClient", "ListResourcesCommand")
+    .f(ListResourcesInputFilterSensitiveLog, ListResourcesOutputFilterSensitiveLog)
+    .ser(se_ListResourcesCommand)
+    .de(de_ListResourcesCommand)
+    .build() {
+}
 
-// src/pagination/ListResourceRequestsPaginator.ts
+class UpdateResourceCommand 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("CloudApiService", "UpdateResource", {})
+    .n("CloudControlClient", "UpdateResourceCommand")
+    .f(UpdateResourceInputFilterSensitiveLog, UpdateResourceOutputFilterSensitiveLog)
+    .ser(se_UpdateResourceCommand)
+    .de(de_UpdateResourceCommand)
+    .build() {
+}
 
-var paginateListResourceRequests = (0, import_core.createPaginator)(CloudControlClient, ListResourceRequestsCommand, "NextToken", "NextToken", "MaxResults");
+const commands = {
+    CancelResourceRequestCommand,
+    CreateResourceCommand,
+    DeleteResourceCommand,
+    GetResourceCommand,
+    GetResourceRequestStatusCommand,
+    ListResourceRequestsCommand,
+    ListResourcesCommand,
+    UpdateResourceCommand,
+};
+class CloudControl extends CloudControlClient {
+}
+smithyClient.createAggregatedClient(commands, CloudControl);
 
-// src/pagination/ListResourcesPaginator.ts
+const paginateListResourceRequests = core.createPaginator(CloudControlClient, ListResourceRequestsCommand, "NextToken", "NextToken", "MaxResults");
 
-var paginateListResources = (0, import_core.createPaginator)(CloudControlClient, ListResourcesCommand, "NextToken", "NextToken", "MaxResults");
+const paginateListResources = core.createPaginator(CloudControlClient, ListResourcesCommand, "NextToken", "NextToken", "MaxResults");
 
-// src/waiters/waitForResourceRequestSuccess.ts
-var import_util_waiter = require("@smithy/util-waiter");
-var checkState = /* @__PURE__ */ __name(async (client, input) => {
-  let reason;
-  try {
-    const result = await client.send(new GetResourceRequestStatusCommand(input));
-    reason = result;
-    try {
-      const returnComparator = /* @__PURE__ */ __name(() => {
-        return result.ProgressEvent.OperationStatus;
-      }, "returnComparator");
-      if (returnComparator() === "SUCCESS") {
-        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
-      }
-    } catch (e) {
-    }
+const checkState = async (client, input) => {
+    let reason;
     try {
-      const returnComparator = /* @__PURE__ */ __name(() => {
-        return result.ProgressEvent.OperationStatus;
-      }, "returnComparator");
-      if (returnComparator() === "FAILED") {
-        return { state: import_util_waiter.WaiterState.FAILURE, reason };
-      }
-    } catch (e) {
+        const result = await client.send(new GetResourceRequestStatusCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                return result.ProgressEvent.OperationStatus;
+            };
+            if (returnComparator() === "SUCCESS") {
+                return { state: utilWaiter.WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.ProgressEvent.OperationStatus;
+            };
+            if (returnComparator() === "FAILED") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
+        try {
+            const returnComparator = () => {
+                return result.ProgressEvent.OperationStatus;
+            };
+            if (returnComparator() === "CANCEL_COMPLETE") {
+                return { state: utilWaiter.WaiterState.FAILURE, reason };
+            }
+        }
+        catch (e) { }
     }
-    try {
-      const returnComparator = /* @__PURE__ */ __name(() => {
-        return result.ProgressEvent.OperationStatus;
-      }, "returnComparator");
-      if (returnComparator() === "CANCEL_COMPLETE") {
-        return { state: import_util_waiter.WaiterState.FAILURE, reason };
-      }
-    } catch (e) {
+    catch (exception) {
+        reason = exception;
     }
-  } catch (exception) {
-    reason = exception;
-  }
-  return { state: import_util_waiter.WaiterState.RETRY, reason };
-}, "checkState");
-var waitForResourceRequestSuccess = /* @__PURE__ */ __name(async (params, input) => {
-  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-}, "waitForResourceRequestSuccess");
-var waitUntilResourceRequestSuccess = /* @__PURE__ */ __name(async (params, input) => {
-  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
-  return (0, import_util_waiter.checkExceptions)(result);
-}, "waitUntilResourceRequestSuccess");
-// Annotate the CommonJS export names for ESM import in node:
+    return { state: utilWaiter.WaiterState.RETRY, reason };
+};
+const waitForResourceRequestSuccess = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+const waitUntilResourceRequestSuccess = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await utilWaiter.createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return utilWaiter.checkExceptions(result);
+};
 
-0 && (module.exports = {
-  CloudControlServiceException,
-  __Client,
-  CloudControlClient,
-  CloudControl,
-  $Command,
-  CancelResourceRequestCommand,
-  CreateResourceCommand,
-  DeleteResourceCommand,
-  GetResourceCommand,
-  GetResourceRequestStatusCommand,
-  ListResourceRequestsCommand,
-  ListResourcesCommand,
-  UpdateResourceCommand,
-  paginateListResourceRequests,
-  paginateListResources,
-  waitForResourceRequestSuccess,
-  waitUntilResourceRequestSuccess,
-  AlreadyExistsException,
-  HandlerErrorCode,
-  Operation,
-  OperationStatus,
-  ConcurrentModificationException,
-  RequestTokenNotFoundException,
-  ClientTokenConflictException,
-  ConcurrentOperationException,
-  GeneralServiceException,
-  HandlerFailureException,
-  HandlerInternalFailureException,
-  InvalidCredentialsException,
-  InvalidRequestException,
-  NetworkFailureException,
-  NotStabilizedException,
-  NotUpdatableException,
-  PrivateTypeException,
-  ResourceConflictException,
-  ResourceNotFoundException,
-  ServiceInternalErrorException,
-  ServiceLimitExceededException,
-  ThrottlingException,
-  TypeNotFoundException,
-  UnsupportedActionException,
-  ProgressEventFilterSensitiveLog,
-  CancelResourceRequestOutputFilterSensitiveLog,
-  CreateResourceInputFilterSensitiveLog,
-  CreateResourceOutputFilterSensitiveLog,
-  DeleteResourceOutputFilterSensitiveLog,
-  ResourceDescriptionFilterSensitiveLog,
-  GetResourceOutputFilterSensitiveLog,
-  GetResourceRequestStatusOutputFilterSensitiveLog,
-  ListResourceRequestsOutputFilterSensitiveLog,
-  ListResourcesInputFilterSensitiveLog,
-  ListResourcesOutputFilterSensitiveLog,
-  UpdateResourceInputFilterSensitiveLog,
-  UpdateResourceOutputFilterSensitiveLog
+Object.defineProperty(exports, "$Command", {
+    enumerable: true,
+    get: function () { return smithyClient.Command; }
 });
-
+Object.defineProperty(exports, "__Client", {
+    enumerable: true,
+    get: function () { return smithyClient.Client; }
+});
+exports.AlreadyExistsException = AlreadyExistsException;
+exports.CancelResourceRequestCommand = CancelResourceRequestCommand;
+exports.CancelResourceRequestOutputFilterSensitiveLog = CancelResourceRequestOutputFilterSensitiveLog;
+exports.ClientTokenConflictException = ClientTokenConflictException;
+exports.CloudControl = CloudControl;
+exports.CloudControlClient = CloudControlClient;
+exports.CloudControlServiceException = CloudControlServiceException;
+exports.ConcurrentModificationException = ConcurrentModificationException;
+exports.ConcurrentOperationException = ConcurrentOperationException;
+exports.CreateResourceCommand = CreateResourceCommand;
+exports.CreateResourceInputFilterSensitiveLog = CreateResourceInputFilterSensitiveLog;
+exports.CreateResourceOutputFilterSensitiveLog = CreateResourceOutputFilterSensitiveLog;
+exports.DeleteResourceCommand = DeleteResourceCommand;
+exports.DeleteResourceOutputFilterSensitiveLog = DeleteResourceOutputFilterSensitiveLog;
+exports.GeneralServiceException = GeneralServiceException;
+exports.GetResourceCommand = GetResourceCommand;
+exports.GetResourceOutputFilterSensitiveLog = GetResourceOutputFilterSensitiveLog;
+exports.GetResourceRequestStatusCommand = GetResourceRequestStatusCommand;
+exports.GetResourceRequestStatusOutputFilterSensitiveLog = GetResourceRequestStatusOutputFilterSensitiveLog;
+exports.HandlerErrorCode = HandlerErrorCode;
+exports.HandlerFailureException = HandlerFailureException;
+exports.HandlerInternalFailureException = HandlerInternalFailureException;
+exports.InvalidCredentialsException = InvalidCredentialsException;
+exports.InvalidRequestException = InvalidRequestException;
+exports.ListResourceRequestsCommand = ListResourceRequestsCommand;
+exports.ListResourceRequestsOutputFilterSensitiveLog = ListResourceRequestsOutputFilterSensitiveLog;
+exports.ListResourcesCommand = ListResourcesCommand;
+exports.ListResourcesInputFilterSensitiveLog = ListResourcesInputFilterSensitiveLog;
+exports.ListResourcesOutputFilterSensitiveLog = ListResourcesOutputFilterSensitiveLog;
+exports.NetworkFailureException = NetworkFailureException;
+exports.NotStabilizedException = NotStabilizedException;
+exports.NotUpdatableException = NotUpdatableException;
+exports.Operation = Operation;
+exports.OperationStatus = OperationStatus;
+exports.PrivateTypeException = PrivateTypeException;
+exports.ProgressEventFilterSensitiveLog = ProgressEventFilterSensitiveLog;
+exports.RequestTokenNotFoundException = RequestTokenNotFoundException;
+exports.ResourceConflictException = ResourceConflictException;
+exports.ResourceDescriptionFilterSensitiveLog = ResourceDescriptionFilterSensitiveLog;
+exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ServiceInternalErrorException = ServiceInternalErrorException;
+exports.ServiceLimitExceededException = ServiceLimitExceededException;
+exports.ThrottlingException = ThrottlingException;
+exports.TypeNotFoundException = TypeNotFoundException;
+exports.UnsupportedActionException = UnsupportedActionException;
+exports.UpdateResourceCommand = UpdateResourceCommand;
+exports.UpdateResourceInputFilterSensitiveLog = UpdateResourceInputFilterSensitiveLog;
+exports.UpdateResourceOutputFilterSensitiveLog = UpdateResourceOutputFilterSensitiveLog;
+exports.paginateListResourceRequests = paginateListResourceRequests;
+exports.paginateListResources = paginateListResources;
+exports.waitForResourceRequestSuccess = waitForResourceRequestSuccess;
+exports.waitUntilResourceRequestSuccess = waitUntilResourceRequestSuccess;