@aws-sdk/client-support 3.490.0 → 3.495.0

package/dist-cjs/index.js

@@ -1,12 +1,1648 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SupportServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./SupportClient"), exports);
-tslib_1.__exportStar(require("./Support"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var SupportServiceException_1 = require("./models/SupportServiceException");
-Object.defineProperty(exports, "SupportServiceException", { enumerable: true, get: function () { return SupportServiceException_1.SupportServiceException; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AddAttachmentsToSetCommand: () => AddAttachmentsToSetCommand,
+  AddCommunicationToCaseCommand: () => AddCommunicationToCaseCommand,
+  AttachmentIdNotFound: () => AttachmentIdNotFound,
+  AttachmentLimitExceeded: () => AttachmentLimitExceeded,
+  AttachmentSetExpired: () => AttachmentSetExpired,
+  AttachmentSetIdNotFound: () => AttachmentSetIdNotFound,
+  AttachmentSetSizeLimitExceeded: () => AttachmentSetSizeLimitExceeded,
+  CaseCreationLimitExceeded: () => CaseCreationLimitExceeded,
+  CaseIdNotFound: () => CaseIdNotFound,
+  CreateCaseCommand: () => CreateCaseCommand,
+  DescribeAttachmentCommand: () => DescribeAttachmentCommand,
+  DescribeAttachmentLimitExceeded: () => DescribeAttachmentLimitExceeded,
+  DescribeCasesCommand: () => DescribeCasesCommand,
+  DescribeCommunicationsCommand: () => DescribeCommunicationsCommand,
+  DescribeCreateCaseOptionsCommand: () => DescribeCreateCaseOptionsCommand,
+  DescribeServicesCommand: () => DescribeServicesCommand,
+  DescribeSeverityLevelsCommand: () => DescribeSeverityLevelsCommand,
+  DescribeSupportedLanguagesCommand: () => DescribeSupportedLanguagesCommand,
+  DescribeTrustedAdvisorCheckRefreshStatusesCommand: () => DescribeTrustedAdvisorCheckRefreshStatusesCommand,
+  DescribeTrustedAdvisorCheckResultCommand: () => DescribeTrustedAdvisorCheckResultCommand,
+  DescribeTrustedAdvisorCheckSummariesCommand: () => DescribeTrustedAdvisorCheckSummariesCommand,
+  DescribeTrustedAdvisorChecksCommand: () => DescribeTrustedAdvisorChecksCommand,
+  InternalServerError: () => InternalServerError,
+  RefreshTrustedAdvisorCheckCommand: () => RefreshTrustedAdvisorCheckCommand,
+  ResolveCaseCommand: () => ResolveCaseCommand,
+  Support: () => Support,
+  SupportClient: () => SupportClient,
+  SupportServiceException: () => SupportServiceException,
+  ThrottlingException: () => ThrottlingException,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeCases: () => paginateDescribeCases,
+  paginateDescribeCommunications: () => paginateDescribeCommunications
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/SupportClient.ts
+var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
+var import_middleware_logger = require("@aws-sdk/middleware-logger");
+var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
+var import_middleware_signing = require("@aws-sdk/middleware-signing");
+var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
+var import_config_resolver = require("@smithy/config-resolver");
+var import_middleware_content_length = require("@smithy/middleware-content-length");
+var import_middleware_endpoint = require("@smithy/middleware-endpoint");
+var import_middleware_retry = require("@smithy/middleware-retry");
+
+
+// src/endpoint/EndpointParameters.ts
+var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
+  return {
+    ...options,
+    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+    useFipsEndpoint: options.useFipsEndpoint ?? false,
+    defaultSigningName: "support"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/SupportClient.ts
+var import_runtimeConfig = require("././runtimeConfig");
+
+// src/runtimeExtensions.ts
+var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
+var import_protocol_http = require("@smithy/protocol-http");
+var import_smithy_client = require("@smithy/smithy-client");
+var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
+var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
+  const extensionConfiguration = {
+    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
+    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig))
+  };
+  extensions.forEach((extension) => extension.configure(extensionConfiguration));
+  return {
+    ...runtimeConfig,
+    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
+    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
+    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration)
+  };
+}, "resolveRuntimeExtensions");
+
+// src/SupportClient.ts
+var _SupportClient = class _SupportClient extends import_smithy_client.Client {
+  constructor(...[configuration]) {
+    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
+    const _config_1 = resolveClientEndpointParameters(_config_0);
+    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
+    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
+    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
+    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
+    const _config_6 = (0, import_middleware_signing.resolveAwsAuthConfig)(_config_5);
+    const _config_7 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_6);
+    const _config_8 = resolveRuntimeExtensions(_config_7, (configuration == null ? void 0 : configuration.extensions) || []);
+    super(_config_8);
+    this.config = _config_8;
+    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_signing.getAwsAuthPlugin)(this.config));
+    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
+  }
+  /**
+   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
+   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
+   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
+   */
+  destroy() {
+    super.destroy();
+  }
+};
+__name(_SupportClient, "SupportClient");
+var SupportClient = _SupportClient;
+
+// src/Support.ts
+
+
+// src/commands/AddAttachmentsToSetCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/SupportServiceException.ts
+
+var _SupportServiceException = class _SupportServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _SupportServiceException.prototype);
+  }
+};
+__name(_SupportServiceException, "SupportServiceException");
+var SupportServiceException = _SupportServiceException;
+
+// src/models/models_0.ts
+var _AttachmentLimitExceeded = class _AttachmentLimitExceeded extends SupportServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AttachmentLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AttachmentLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AttachmentLimitExceeded.prototype);
+  }
+};
+__name(_AttachmentLimitExceeded, "AttachmentLimitExceeded");
+var AttachmentLimitExceeded = _AttachmentLimitExceeded;
+var _AttachmentSetExpired = class _AttachmentSetExpired extends SupportServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AttachmentSetExpired",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AttachmentSetExpired";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AttachmentSetExpired.prototype);
+  }
+};
+__name(_AttachmentSetExpired, "AttachmentSetExpired");
+var AttachmentSetExpired = _AttachmentSetExpired;
+var _AttachmentSetIdNotFound = class _AttachmentSetIdNotFound extends SupportServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AttachmentSetIdNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AttachmentSetIdNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AttachmentSetIdNotFound.prototype);
+  }
+};
+__name(_AttachmentSetIdNotFound, "AttachmentSetIdNotFound");
+var AttachmentSetIdNotFound = _AttachmentSetIdNotFound;
+var _AttachmentSetSizeLimitExceeded = class _AttachmentSetSizeLimitExceeded extends SupportServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AttachmentSetSizeLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AttachmentSetSizeLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AttachmentSetSizeLimitExceeded.prototype);
+  }
+};
+__name(_AttachmentSetSizeLimitExceeded, "AttachmentSetSizeLimitExceeded");
+var AttachmentSetSizeLimitExceeded = _AttachmentSetSizeLimitExceeded;
+var _InternalServerError = class _InternalServerError extends SupportServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerError",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerError";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerError.prototype);
+  }
+};
+__name(_InternalServerError, "InternalServerError");
+var InternalServerError = _InternalServerError;
+var _CaseIdNotFound = class _CaseIdNotFound extends SupportServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CaseIdNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "CaseIdNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _CaseIdNotFound.prototype);
+  }
+};
+__name(_CaseIdNotFound, "CaseIdNotFound");
+var CaseIdNotFound = _CaseIdNotFound;
+var _AttachmentIdNotFound = class _AttachmentIdNotFound extends SupportServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AttachmentIdNotFound",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AttachmentIdNotFound";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AttachmentIdNotFound.prototype);
+  }
+};
+__name(_AttachmentIdNotFound, "AttachmentIdNotFound");
+var AttachmentIdNotFound = _AttachmentIdNotFound;
+var _CaseCreationLimitExceeded = class _CaseCreationLimitExceeded extends SupportServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "CaseCreationLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "CaseCreationLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _CaseCreationLimitExceeded.prototype);
+  }
+};
+__name(_CaseCreationLimitExceeded, "CaseCreationLimitExceeded");
+var CaseCreationLimitExceeded = _CaseCreationLimitExceeded;
+var _DescribeAttachmentLimitExceeded = class _DescribeAttachmentLimitExceeded extends SupportServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "DescribeAttachmentLimitExceeded",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "DescribeAttachmentLimitExceeded";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _DescribeAttachmentLimitExceeded.prototype);
+  }
+};
+__name(_DescribeAttachmentLimitExceeded, "DescribeAttachmentLimitExceeded");
+var DescribeAttachmentLimitExceeded = _DescribeAttachmentLimitExceeded;
+var _ThrottlingException = class _ThrottlingException extends SupportServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+
+// src/protocols/Aws_json1_1.ts
+var se_AddAttachmentsToSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AddAttachmentsToSet");
+  let body;
+  body = JSON.stringify(se_AddAttachmentsToSetRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AddAttachmentsToSetCommand");
+var se_AddCommunicationToCaseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("AddCommunicationToCase");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_AddCommunicationToCaseCommand");
+var se_CreateCaseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("CreateCase");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_CreateCaseCommand");
+var se_DescribeAttachmentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeAttachment");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeAttachmentCommand");
+var se_DescribeCasesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeCases");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeCasesCommand");
+var se_DescribeCommunicationsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeCommunications");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeCommunicationsCommand");
+var se_DescribeCreateCaseOptionsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeCreateCaseOptions");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeCreateCaseOptionsCommand");
+var se_DescribeServicesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeServices");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeServicesCommand");
+var se_DescribeSeverityLevelsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeSeverityLevels");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeSeverityLevelsCommand");
+var se_DescribeSupportedLanguagesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeSupportedLanguages");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeSupportedLanguagesCommand");
+var se_DescribeTrustedAdvisorCheckRefreshStatusesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeTrustedAdvisorCheckRefreshStatuses");
+  let body;
+  body = JSON.stringify(se_DescribeTrustedAdvisorCheckRefreshStatusesRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeTrustedAdvisorCheckRefreshStatusesCommand");
+var se_DescribeTrustedAdvisorCheckResultCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeTrustedAdvisorCheckResult");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeTrustedAdvisorCheckResultCommand");
+var se_DescribeTrustedAdvisorChecksCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeTrustedAdvisorChecks");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeTrustedAdvisorChecksCommand");
+var se_DescribeTrustedAdvisorCheckSummariesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeTrustedAdvisorCheckSummaries");
+  let body;
+  body = JSON.stringify(se_DescribeTrustedAdvisorCheckSummariesRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeTrustedAdvisorCheckSummariesCommand");
+var se_RefreshTrustedAdvisorCheckCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("RefreshTrustedAdvisorCheck");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_RefreshTrustedAdvisorCheckCommand");
+var se_ResolveCaseCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("ResolveCase");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_ResolveCaseCommand");
+var de_AddAttachmentsToSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AddAttachmentsToSetCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AddAttachmentsToSetCommand");
+var de_AddAttachmentsToSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AttachmentLimitExceeded":
+    case "com.amazonaws.support#AttachmentLimitExceeded":
+      throw await de_AttachmentLimitExceededRes(parsedOutput, context);
+    case "AttachmentSetExpired":
+    case "com.amazonaws.support#AttachmentSetExpired":
+      throw await de_AttachmentSetExpiredRes(parsedOutput, context);
+    case "AttachmentSetIdNotFound":
+    case "com.amazonaws.support#AttachmentSetIdNotFound":
+      throw await de_AttachmentSetIdNotFoundRes(parsedOutput, context);
+    case "AttachmentSetSizeLimitExceeded":
+    case "com.amazonaws.support#AttachmentSetSizeLimitExceeded":
+      throw await de_AttachmentSetSizeLimitExceededRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddAttachmentsToSetCommandError");
+var de_AddCommunicationToCaseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_AddCommunicationToCaseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_AddCommunicationToCaseCommand");
+var de_AddCommunicationToCaseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AttachmentSetExpired":
+    case "com.amazonaws.support#AttachmentSetExpired":
+      throw await de_AttachmentSetExpiredRes(parsedOutput, context);
+    case "AttachmentSetIdNotFound":
+    case "com.amazonaws.support#AttachmentSetIdNotFound":
+      throw await de_AttachmentSetIdNotFoundRes(parsedOutput, context);
+    case "CaseIdNotFound":
+    case "com.amazonaws.support#CaseIdNotFound":
+      throw await de_CaseIdNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_AddCommunicationToCaseCommandError");
+var de_CreateCaseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_CreateCaseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_CreateCaseCommand");
+var de_CreateCaseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AttachmentSetExpired":
+    case "com.amazonaws.support#AttachmentSetExpired":
+      throw await de_AttachmentSetExpiredRes(parsedOutput, context);
+    case "AttachmentSetIdNotFound":
+    case "com.amazonaws.support#AttachmentSetIdNotFound":
+      throw await de_AttachmentSetIdNotFoundRes(parsedOutput, context);
+    case "CaseCreationLimitExceeded":
+    case "com.amazonaws.support#CaseCreationLimitExceeded":
+      throw await de_CaseCreationLimitExceededRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateCaseCommandError");
+var de_DescribeAttachmentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeAttachmentCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeAttachmentResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeAttachmentCommand");
+var de_DescribeAttachmentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AttachmentIdNotFound":
+    case "com.amazonaws.support#AttachmentIdNotFound":
+      throw await de_AttachmentIdNotFoundRes(parsedOutput, context);
+    case "DescribeAttachmentLimitExceeded":
+    case "com.amazonaws.support#DescribeAttachmentLimitExceeded":
+      throw await de_DescribeAttachmentLimitExceededRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeAttachmentCommandError");
+var de_DescribeCasesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeCasesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeCasesCommand");
+var de_DescribeCasesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CaseIdNotFound":
+    case "com.amazonaws.support#CaseIdNotFound":
+      throw await de_CaseIdNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCasesCommandError");
+var de_DescribeCommunicationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeCommunicationsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeCommunicationsCommand");
+var de_DescribeCommunicationsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CaseIdNotFound":
+    case "com.amazonaws.support#CaseIdNotFound":
+      throw await de_CaseIdNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCommunicationsCommandError");
+var de_DescribeCreateCaseOptionsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeCreateCaseOptionsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeCreateCaseOptionsCommand");
+var de_DescribeCreateCaseOptionsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.support#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeCreateCaseOptionsCommandError");
+var de_DescribeServicesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeServicesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeServicesCommand");
+var de_DescribeServicesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeServicesCommandError");
+var de_DescribeSeverityLevelsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeSeverityLevelsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeSeverityLevelsCommand");
+var de_DescribeSeverityLevelsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeSeverityLevelsCommandError");
+var de_DescribeSupportedLanguagesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeSupportedLanguagesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeSupportedLanguagesCommand");
+var de_DescribeSupportedLanguagesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.support#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeSupportedLanguagesCommandError");
+var de_DescribeTrustedAdvisorCheckRefreshStatusesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeTrustedAdvisorCheckRefreshStatusesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeTrustedAdvisorCheckRefreshStatusesCommand");
+var de_DescribeTrustedAdvisorCheckRefreshStatusesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.support#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeTrustedAdvisorCheckRefreshStatusesCommandError");
+var de_DescribeTrustedAdvisorCheckResultCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeTrustedAdvisorCheckResultCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeTrustedAdvisorCheckResultResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeTrustedAdvisorCheckResultCommand");
+var de_DescribeTrustedAdvisorCheckResultCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.support#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeTrustedAdvisorCheckResultCommandError");
+var de_DescribeTrustedAdvisorChecksCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeTrustedAdvisorChecksCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeTrustedAdvisorChecksResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeTrustedAdvisorChecksCommand");
+var de_DescribeTrustedAdvisorChecksCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.support#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeTrustedAdvisorChecksCommandError");
+var de_DescribeTrustedAdvisorCheckSummariesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeTrustedAdvisorCheckSummariesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeTrustedAdvisorCheckSummariesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeTrustedAdvisorCheckSummariesCommand");
+var de_DescribeTrustedAdvisorCheckSummariesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.support#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeTrustedAdvisorCheckSummariesCommandError");
+var de_RefreshTrustedAdvisorCheckCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_RefreshTrustedAdvisorCheckCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_RefreshTrustedAdvisorCheckCommand");
+var de_RefreshTrustedAdvisorCheckCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_RefreshTrustedAdvisorCheckCommandError");
+var de_ResolveCaseCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_ResolveCaseCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = (0, import_smithy_client._json)(data);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_ResolveCaseCommand");
+var de_ResolveCaseCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "CaseIdNotFound":
+    case "com.amazonaws.support#CaseIdNotFound":
+      throw await de_CaseIdNotFoundRes(parsedOutput, context);
+    case "InternalServerError":
+    case "com.amazonaws.support#InternalServerError":
+      throw await de_InternalServerErrorRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ResolveCaseCommandError");
+var de_AttachmentIdNotFoundRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AttachmentIdNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AttachmentIdNotFoundRes");
+var de_AttachmentLimitExceededRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AttachmentLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AttachmentLimitExceededRes");
+var de_AttachmentSetExpiredRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AttachmentSetExpired({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AttachmentSetExpiredRes");
+var de_AttachmentSetIdNotFoundRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AttachmentSetIdNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AttachmentSetIdNotFoundRes");
+var de_AttachmentSetSizeLimitExceededRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new AttachmentSetSizeLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_AttachmentSetSizeLimitExceededRes");
+var de_CaseCreationLimitExceededRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new CaseCreationLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CaseCreationLimitExceededRes");
+var de_CaseIdNotFoundRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new CaseIdNotFound({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_CaseIdNotFoundRes");
+var de_DescribeAttachmentLimitExceededRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new DescribeAttachmentLimitExceeded({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_DescribeAttachmentLimitExceededRes");
+var de_InternalServerErrorRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InternalServerError({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InternalServerErrorRes");
+var de_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 se_AddAttachmentsToSetRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    attachmentSetId: [],
+    attachments: (_) => se_Attachments(_, context)
+  });
+}, "se_AddAttachmentsToSetRequest");
+var se_Attachment = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    data: context.base64Encoder,
+    fileName: []
+  });
+}, "se_Attachment");
+var se_Attachments = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Attachment(entry, context);
+  });
+}, "se_Attachments");
+var se_DescribeTrustedAdvisorCheckRefreshStatusesRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    checkIds: (_) => se_StringList(_, context)
+  });
+}, "se_DescribeTrustedAdvisorCheckRefreshStatusesRequest");
+var se_DescribeTrustedAdvisorCheckSummariesRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    checkIds: (_) => se_StringList(_, context)
+  });
+}, "se_DescribeTrustedAdvisorCheckSummariesRequest");
+var se_StringList = /* @__PURE__ */ __name((input, context) => {
+  return input;
+}, "se_StringList");
+var de_Attachment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    data: context.base64Decoder,
+    fileName: import_smithy_client.expectString
+  });
+}, "de_Attachment");
+var de_DescribeAttachmentResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    attachment: (_) => de_Attachment(_, context)
+  });
+}, "de_DescribeAttachmentResponse");
+var de_DescribeTrustedAdvisorCheckResultResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    result: (_) => de_TrustedAdvisorCheckResult(_, context)
+  });
+}, "de_DescribeTrustedAdvisorCheckResultResponse");
+var de_DescribeTrustedAdvisorChecksResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    checks: (_) => de_TrustedAdvisorCheckList(_, context)
+  });
+}, "de_DescribeTrustedAdvisorChecksResponse");
+var de_DescribeTrustedAdvisorCheckSummariesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    summaries: (_) => de_TrustedAdvisorCheckSummaryList(_, context)
+  });
+}, "de_DescribeTrustedAdvisorCheckSummariesResponse");
+var de_StringList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).map((entry) => {
+    if (entry === null) {
+      return null;
+    }
+    return (0, import_smithy_client.expectString)(entry);
+  });
+  return retVal;
+}, "de_StringList");
+var de_TrustedAdvisorCategorySpecificSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    costOptimizing: (_) => de_TrustedAdvisorCostOptimizingSummary(_, context)
+  });
+}, "de_TrustedAdvisorCategorySpecificSummary");
+var de_TrustedAdvisorCheckDescription = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    category: import_smithy_client.expectString,
+    description: import_smithy_client.expectString,
+    id: import_smithy_client.expectString,
+    metadata: (_) => de_StringList(_, context),
+    name: import_smithy_client.expectString
+  });
+}, "de_TrustedAdvisorCheckDescription");
+var de_TrustedAdvisorCheckList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_TrustedAdvisorCheckDescription(entry, context);
+  });
+  return retVal;
+}, "de_TrustedAdvisorCheckList");
+var de_TrustedAdvisorCheckResult = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    categorySpecificSummary: (_) => de_TrustedAdvisorCategorySpecificSummary(_, context),
+    checkId: import_smithy_client.expectString,
+    flaggedResources: (_) => de_TrustedAdvisorResourceDetailList(_, context),
+    resourcesSummary: import_smithy_client._json,
+    status: import_smithy_client.expectString,
+    timestamp: import_smithy_client.expectString
+  });
+}, "de_TrustedAdvisorCheckResult");
+var de_TrustedAdvisorCheckSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    categorySpecificSummary: (_) => de_TrustedAdvisorCategorySpecificSummary(_, context),
+    checkId: import_smithy_client.expectString,
+    hasFlaggedResources: import_smithy_client.expectBoolean,
+    resourcesSummary: import_smithy_client._json,
+    status: import_smithy_client.expectString,
+    timestamp: import_smithy_client.expectString
+  });
+}, "de_TrustedAdvisorCheckSummary");
+var de_TrustedAdvisorCheckSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_TrustedAdvisorCheckSummary(entry, context);
+  });
+  return retVal;
+}, "de_TrustedAdvisorCheckSummaryList");
+var de_TrustedAdvisorCostOptimizingSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    estimatedMonthlySavings: import_smithy_client.limitedParseDouble,
+    estimatedPercentMonthlySavings: import_smithy_client.limitedParseDouble
+  });
+}, "de_TrustedAdvisorCostOptimizingSummary");
+var de_TrustedAdvisorResourceDetail = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    isSuppressed: import_smithy_client.expectBoolean,
+    metadata: (_) => de_StringList(_, context),
+    region: import_smithy_client.expectString,
+    resourceId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString
+  });
+}, "de_TrustedAdvisorResourceDetail");
+var de_TrustedAdvisorResourceDetailList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_TrustedAdvisorResourceDetail(entry, context);
+  });
+  return retVal;
+}, "de_TrustedAdvisorResourceDetailList");
+var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
+  httpStatusCode: output.statusCode,
+  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+  extendedRequestId: output.headers["x-amz-id-2"],
+  cfId: output.headers["x-amz-cf-id"]
+}), "deserializeMetadata");
+var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(SupportServiceException);
+var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
+  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+  const contents = {
+    protocol,
+    hostname,
+    port,
+    method: "POST",
+    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+    headers
+  };
+  if (resolvedHostname !== void 0) {
+    contents.hostname = resolvedHostname;
+  }
+  if (body !== void 0) {
+    contents.body = body;
+  }
+  return new import_protocol_http.HttpRequest(contents);
+}, "buildHttpRpcRequest");
+function sharedHeaders(operation) {
+  return {
+    "content-type": "application/x-amz-json-1.1",
+    "x-amz-target": `AWSSupport_20130415.${operation}`
+  };
+}
+__name(sharedHeaders, "sharedHeaders");
+var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
+  if (encoded.length) {
+    return JSON.parse(encoded);
+  }
+  return {};
+}), "parseBody");
+var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
+  const value = await parseBody(errorBody, context);
+  value.message = value.message ?? value.Message;
+  return value;
+}, "parseErrorBody");
+var loadRestJsonErrorCode = /* @__PURE__ */ __name((output, data) => {
+  const findKey = /* @__PURE__ */ __name((object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase()), "findKey");
+  const sanitizeErrorCode = /* @__PURE__ */ __name((rawValue) => {
+    let cleanValue = rawValue;
+    if (typeof cleanValue === "number") {
+      cleanValue = cleanValue.toString();
+    }
+    if (cleanValue.indexOf(",") >= 0) {
+      cleanValue = cleanValue.split(",")[0];
+    }
+    if (cleanValue.indexOf(":") >= 0) {
+      cleanValue = cleanValue.split(":")[0];
+    }
+    if (cleanValue.indexOf("#") >= 0) {
+      cleanValue = cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  }, "sanitizeErrorCode");
+  const headerKey = findKey(output.headers, "x-amzn-errortype");
+  if (headerKey !== void 0) {
+    return sanitizeErrorCode(output.headers[headerKey]);
+  }
+  if (data.code !== void 0) {
+    return sanitizeErrorCode(data.code);
+  }
+  if (data["__type"] !== void 0) {
+    return sanitizeErrorCode(data["__type"]);
+  }
+}, "loadRestJsonErrorCode");
+
+// src/commands/AddAttachmentsToSetCommand.ts
+var _AddAttachmentsToSetCommand = class _AddAttachmentsToSetCommand 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("AWSSupport_20130415", "AddAttachmentsToSet", {}).n("SupportClient", "AddAttachmentsToSetCommand").f(void 0, void 0).ser(se_AddAttachmentsToSetCommand).de(de_AddAttachmentsToSetCommand).build() {
+};
+__name(_AddAttachmentsToSetCommand, "AddAttachmentsToSetCommand");
+var AddAttachmentsToSetCommand = _AddAttachmentsToSetCommand;
+
+// src/commands/AddCommunicationToCaseCommand.ts
+
+
+
+
+var _AddCommunicationToCaseCommand = class _AddCommunicationToCaseCommand 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("AWSSupport_20130415", "AddCommunicationToCase", {}).n("SupportClient", "AddCommunicationToCaseCommand").f(void 0, void 0).ser(se_AddCommunicationToCaseCommand).de(de_AddCommunicationToCaseCommand).build() {
+};
+__name(_AddCommunicationToCaseCommand, "AddCommunicationToCaseCommand");
+var AddCommunicationToCaseCommand = _AddCommunicationToCaseCommand;
+
+// src/commands/CreateCaseCommand.ts
+
+
+
+
+var _CreateCaseCommand = class _CreateCaseCommand 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("AWSSupport_20130415", "CreateCase", {}).n("SupportClient", "CreateCaseCommand").f(void 0, void 0).ser(se_CreateCaseCommand).de(de_CreateCaseCommand).build() {
+};
+__name(_CreateCaseCommand, "CreateCaseCommand");
+var CreateCaseCommand = _CreateCaseCommand;
+
+// src/commands/DescribeAttachmentCommand.ts
+
+
+
+
+var _DescribeAttachmentCommand = class _DescribeAttachmentCommand 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("AWSSupport_20130415", "DescribeAttachment", {}).n("SupportClient", "DescribeAttachmentCommand").f(void 0, void 0).ser(se_DescribeAttachmentCommand).de(de_DescribeAttachmentCommand).build() {
+};
+__name(_DescribeAttachmentCommand, "DescribeAttachmentCommand");
+var DescribeAttachmentCommand = _DescribeAttachmentCommand;
+
+// src/commands/DescribeCasesCommand.ts
+
+
+
+
+var _DescribeCasesCommand = class _DescribeCasesCommand 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("AWSSupport_20130415", "DescribeCases", {}).n("SupportClient", "DescribeCasesCommand").f(void 0, void 0).ser(se_DescribeCasesCommand).de(de_DescribeCasesCommand).build() {
+};
+__name(_DescribeCasesCommand, "DescribeCasesCommand");
+var DescribeCasesCommand = _DescribeCasesCommand;
+
+// src/commands/DescribeCommunicationsCommand.ts
+
+
+
+
+var _DescribeCommunicationsCommand = class _DescribeCommunicationsCommand 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("AWSSupport_20130415", "DescribeCommunications", {}).n("SupportClient", "DescribeCommunicationsCommand").f(void 0, void 0).ser(se_DescribeCommunicationsCommand).de(de_DescribeCommunicationsCommand).build() {
+};
+__name(_DescribeCommunicationsCommand, "DescribeCommunicationsCommand");
+var DescribeCommunicationsCommand = _DescribeCommunicationsCommand;
+
+// src/commands/DescribeCreateCaseOptionsCommand.ts
+
+
+
+
+var _DescribeCreateCaseOptionsCommand = class _DescribeCreateCaseOptionsCommand 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("AWSSupport_20130415", "DescribeCreateCaseOptions", {}).n("SupportClient", "DescribeCreateCaseOptionsCommand").f(void 0, void 0).ser(se_DescribeCreateCaseOptionsCommand).de(de_DescribeCreateCaseOptionsCommand).build() {
+};
+__name(_DescribeCreateCaseOptionsCommand, "DescribeCreateCaseOptionsCommand");
+var DescribeCreateCaseOptionsCommand = _DescribeCreateCaseOptionsCommand;
+
+// src/commands/DescribeServicesCommand.ts
+
+
+
+
+var _DescribeServicesCommand = class _DescribeServicesCommand 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("AWSSupport_20130415", "DescribeServices", {}).n("SupportClient", "DescribeServicesCommand").f(void 0, void 0).ser(se_DescribeServicesCommand).de(de_DescribeServicesCommand).build() {
+};
+__name(_DescribeServicesCommand, "DescribeServicesCommand");
+var DescribeServicesCommand = _DescribeServicesCommand;
+
+// src/commands/DescribeSeverityLevelsCommand.ts
+
+
+
+
+var _DescribeSeverityLevelsCommand = class _DescribeSeverityLevelsCommand 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("AWSSupport_20130415", "DescribeSeverityLevels", {}).n("SupportClient", "DescribeSeverityLevelsCommand").f(void 0, void 0).ser(se_DescribeSeverityLevelsCommand).de(de_DescribeSeverityLevelsCommand).build() {
+};
+__name(_DescribeSeverityLevelsCommand, "DescribeSeverityLevelsCommand");
+var DescribeSeverityLevelsCommand = _DescribeSeverityLevelsCommand;
+
+// src/commands/DescribeSupportedLanguagesCommand.ts
+
+
+
+
+var _DescribeSupportedLanguagesCommand = class _DescribeSupportedLanguagesCommand 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("AWSSupport_20130415", "DescribeSupportedLanguages", {}).n("SupportClient", "DescribeSupportedLanguagesCommand").f(void 0, void 0).ser(se_DescribeSupportedLanguagesCommand).de(de_DescribeSupportedLanguagesCommand).build() {
+};
+__name(_DescribeSupportedLanguagesCommand, "DescribeSupportedLanguagesCommand");
+var DescribeSupportedLanguagesCommand = _DescribeSupportedLanguagesCommand;
+
+// src/commands/DescribeTrustedAdvisorCheckRefreshStatusesCommand.ts
+
+
+
+
+var _DescribeTrustedAdvisorCheckRefreshStatusesCommand = class _DescribeTrustedAdvisorCheckRefreshStatusesCommand 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("AWSSupport_20130415", "DescribeTrustedAdvisorCheckRefreshStatuses", {}).n("SupportClient", "DescribeTrustedAdvisorCheckRefreshStatusesCommand").f(void 0, void 0).ser(se_DescribeTrustedAdvisorCheckRefreshStatusesCommand).de(de_DescribeTrustedAdvisorCheckRefreshStatusesCommand).build() {
+};
+__name(_DescribeTrustedAdvisorCheckRefreshStatusesCommand, "DescribeTrustedAdvisorCheckRefreshStatusesCommand");
+var DescribeTrustedAdvisorCheckRefreshStatusesCommand = _DescribeTrustedAdvisorCheckRefreshStatusesCommand;
+
+// src/commands/DescribeTrustedAdvisorCheckResultCommand.ts
+
+
+
+
+var _DescribeTrustedAdvisorCheckResultCommand = class _DescribeTrustedAdvisorCheckResultCommand 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("AWSSupport_20130415", "DescribeTrustedAdvisorCheckResult", {}).n("SupportClient", "DescribeTrustedAdvisorCheckResultCommand").f(void 0, void 0).ser(se_DescribeTrustedAdvisorCheckResultCommand).de(de_DescribeTrustedAdvisorCheckResultCommand).build() {
+};
+__name(_DescribeTrustedAdvisorCheckResultCommand, "DescribeTrustedAdvisorCheckResultCommand");
+var DescribeTrustedAdvisorCheckResultCommand = _DescribeTrustedAdvisorCheckResultCommand;
+
+// src/commands/DescribeTrustedAdvisorChecksCommand.ts
+
+
+
+
+var _DescribeTrustedAdvisorChecksCommand = class _DescribeTrustedAdvisorChecksCommand 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("AWSSupport_20130415", "DescribeTrustedAdvisorChecks", {}).n("SupportClient", "DescribeTrustedAdvisorChecksCommand").f(void 0, void 0).ser(se_DescribeTrustedAdvisorChecksCommand).de(de_DescribeTrustedAdvisorChecksCommand).build() {
+};
+__name(_DescribeTrustedAdvisorChecksCommand, "DescribeTrustedAdvisorChecksCommand");
+var DescribeTrustedAdvisorChecksCommand = _DescribeTrustedAdvisorChecksCommand;
+
+// src/commands/DescribeTrustedAdvisorCheckSummariesCommand.ts
+
+
+
+
+var _DescribeTrustedAdvisorCheckSummariesCommand = class _DescribeTrustedAdvisorCheckSummariesCommand 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("AWSSupport_20130415", "DescribeTrustedAdvisorCheckSummaries", {}).n("SupportClient", "DescribeTrustedAdvisorCheckSummariesCommand").f(void 0, void 0).ser(se_DescribeTrustedAdvisorCheckSummariesCommand).de(de_DescribeTrustedAdvisorCheckSummariesCommand).build() {
+};
+__name(_DescribeTrustedAdvisorCheckSummariesCommand, "DescribeTrustedAdvisorCheckSummariesCommand");
+var DescribeTrustedAdvisorCheckSummariesCommand = _DescribeTrustedAdvisorCheckSummariesCommand;
+
+// src/commands/RefreshTrustedAdvisorCheckCommand.ts
+
+
+
+
+var _RefreshTrustedAdvisorCheckCommand = class _RefreshTrustedAdvisorCheckCommand 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("AWSSupport_20130415", "RefreshTrustedAdvisorCheck", {}).n("SupportClient", "RefreshTrustedAdvisorCheckCommand").f(void 0, void 0).ser(se_RefreshTrustedAdvisorCheckCommand).de(de_RefreshTrustedAdvisorCheckCommand).build() {
+};
+__name(_RefreshTrustedAdvisorCheckCommand, "RefreshTrustedAdvisorCheckCommand");
+var RefreshTrustedAdvisorCheckCommand = _RefreshTrustedAdvisorCheckCommand;
+
+// src/commands/ResolveCaseCommand.ts
+
+
+
+
+var _ResolveCaseCommand = class _ResolveCaseCommand 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("AWSSupport_20130415", "ResolveCase", {}).n("SupportClient", "ResolveCaseCommand").f(void 0, void 0).ser(se_ResolveCaseCommand).de(de_ResolveCaseCommand).build() {
+};
+__name(_ResolveCaseCommand, "ResolveCaseCommand");
+var ResolveCaseCommand = _ResolveCaseCommand;
+
+// src/Support.ts
+var commands = {
+  AddAttachmentsToSetCommand,
+  AddCommunicationToCaseCommand,
+  CreateCaseCommand,
+  DescribeAttachmentCommand,
+  DescribeCasesCommand,
+  DescribeCommunicationsCommand,
+  DescribeCreateCaseOptionsCommand,
+  DescribeServicesCommand,
+  DescribeSeverityLevelsCommand,
+  DescribeSupportedLanguagesCommand,
+  DescribeTrustedAdvisorCheckRefreshStatusesCommand,
+  DescribeTrustedAdvisorCheckResultCommand,
+  DescribeTrustedAdvisorChecksCommand,
+  DescribeTrustedAdvisorCheckSummariesCommand,
+  RefreshTrustedAdvisorCheckCommand,
+  ResolveCaseCommand
+};
+var _Support = class _Support extends SupportClient {
+};
+__name(_Support, "Support");
+var Support = _Support;
+(0, import_smithy_client.createAggregatedClient)(commands, Support);
+
+// src/pagination/DescribeCasesPaginator.ts
+var import_core = require("@smithy/core");
+var paginateDescribeCases = (0, import_core.createPaginator)(SupportClient, DescribeCasesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribeCommunicationsPaginator.ts
+
+var paginateDescribeCommunications = (0, import_core.createPaginator)(SupportClient, DescribeCommunicationsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/index.ts
+var import_util_endpoints = require("@aws-sdk/util-endpoints");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AddAttachmentsToSetCommand,
+  AddCommunicationToCaseCommand,
+  AttachmentIdNotFound,
+  AttachmentLimitExceeded,
+  AttachmentSetExpired,
+  AttachmentSetIdNotFound,
+  AttachmentSetSizeLimitExceeded,
+  CaseCreationLimitExceeded,
+  CaseIdNotFound,
+  CreateCaseCommand,
+  DescribeAttachmentCommand,
+  DescribeAttachmentLimitExceeded,
+  DescribeCasesCommand,
+  DescribeCommunicationsCommand,
+  DescribeCreateCaseOptionsCommand,
+  DescribeServicesCommand,
+  DescribeSeverityLevelsCommand,
+  DescribeSupportedLanguagesCommand,
+  DescribeTrustedAdvisorCheckRefreshStatusesCommand,
+  DescribeTrustedAdvisorCheckResultCommand,
+  DescribeTrustedAdvisorCheckSummariesCommand,
+  DescribeTrustedAdvisorChecksCommand,
+  InternalServerError,
+  RefreshTrustedAdvisorCheckCommand,
+  ResolveCaseCommand,
+  Support,
+  SupportClient,
+  SupportServiceException,
+  ThrottlingException,
+  __Client,
+  paginateDescribeCases,
+  paginateDescribeCommunications
+});