@aws-sdk/client-health 3.490.0 → 3.496.0

package/dist-cjs/index.js

@@ -1,12 +1,1405 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HealthServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./HealthClient"), exports);
-tslib_1.__exportStar(require("./Health"), 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 HealthServiceException_1 = require("./models/HealthServiceException");
-Object.defineProperty(exports, "HealthServiceException", { enumerable: true, get: function () { return HealthServiceException_1.HealthServiceException; } });
+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, {
+  ConcurrentModificationException: () => ConcurrentModificationException,
+  DescribeAffectedAccountsForOrganizationCommand: () => DescribeAffectedAccountsForOrganizationCommand,
+  DescribeAffectedEntitiesCommand: () => DescribeAffectedEntitiesCommand,
+  DescribeAffectedEntitiesForOrganizationCommand: () => DescribeAffectedEntitiesForOrganizationCommand,
+  DescribeEntityAggregatesCommand: () => DescribeEntityAggregatesCommand,
+  DescribeEntityAggregatesForOrganizationCommand: () => DescribeEntityAggregatesForOrganizationCommand,
+  DescribeEventAggregatesCommand: () => DescribeEventAggregatesCommand,
+  DescribeEventDetailsCommand: () => DescribeEventDetailsCommand,
+  DescribeEventDetailsForOrganizationCommand: () => DescribeEventDetailsForOrganizationCommand,
+  DescribeEventTypesCommand: () => DescribeEventTypesCommand,
+  DescribeEventsCommand: () => DescribeEventsCommand,
+  DescribeEventsForOrganizationCommand: () => DescribeEventsForOrganizationCommand,
+  DescribeHealthServiceStatusForOrganizationCommand: () => DescribeHealthServiceStatusForOrganizationCommand,
+  DisableHealthServiceAccessForOrganizationCommand: () => DisableHealthServiceAccessForOrganizationCommand,
+  EnableHealthServiceAccessForOrganizationCommand: () => EnableHealthServiceAccessForOrganizationCommand,
+  EntityStatusCode: () => EntityStatusCode,
+  EventAggregateField: () => EventAggregateField,
+  EventScopeCode: () => EventScopeCode,
+  EventStatusCode: () => EventStatusCode,
+  EventTypeCategory: () => EventTypeCategory,
+  Health: () => Health,
+  HealthClient: () => HealthClient,
+  HealthServiceException: () => HealthServiceException,
+  InvalidPaginationToken: () => InvalidPaginationToken,
+  UnsupportedLocale: () => UnsupportedLocale,
+  __Client: () => import_smithy_client.Client,
+  paginateDescribeAffectedAccountsForOrganization: () => paginateDescribeAffectedAccountsForOrganization,
+  paginateDescribeAffectedEntities: () => paginateDescribeAffectedEntities,
+  paginateDescribeAffectedEntitiesForOrganization: () => paginateDescribeAffectedEntitiesForOrganization,
+  paginateDescribeEventAggregates: () => paginateDescribeEventAggregates,
+  paginateDescribeEventTypes: () => paginateDescribeEventTypes,
+  paginateDescribeEvents: () => paginateDescribeEvents,
+  paginateDescribeEventsForOrganization: () => paginateDescribeEventsForOrganization
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/HealthClient.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: "health"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/HealthClient.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/HealthClient.ts
+var _HealthClient = class _HealthClient 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(_HealthClient, "HealthClient");
+var HealthClient = _HealthClient;
+
+// src/Health.ts
+
+
+// src/commands/DescribeAffectedAccountsForOrganizationCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_json1_1.ts
+
+
+
+// src/models/HealthServiceException.ts
+
+var _HealthServiceException = class _HealthServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _HealthServiceException.prototype);
+  }
+};
+__name(_HealthServiceException, "HealthServiceException");
+var HealthServiceException = _HealthServiceException;
+
+// src/models/models_0.ts
+var EntityStatusCode = {
+  IMPAIRED: "IMPAIRED",
+  PENDING: "PENDING",
+  RESOLVED: "RESOLVED",
+  UNIMPAIRED: "UNIMPAIRED",
+  UNKNOWN: "UNKNOWN"
+};
+var EventScopeCode = {
+  ACCOUNT_SPECIFIC: "ACCOUNT_SPECIFIC",
+  NONE: "NONE",
+  PUBLIC: "PUBLIC"
+};
+var _InvalidPaginationToken = class _InvalidPaginationToken extends HealthServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InvalidPaginationToken",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "InvalidPaginationToken";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _InvalidPaginationToken.prototype);
+  }
+};
+__name(_InvalidPaginationToken, "InvalidPaginationToken");
+var InvalidPaginationToken = _InvalidPaginationToken;
+var _UnsupportedLocale = class _UnsupportedLocale extends HealthServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "UnsupportedLocale",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "UnsupportedLocale";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _UnsupportedLocale.prototype);
+  }
+};
+__name(_UnsupportedLocale, "UnsupportedLocale");
+var UnsupportedLocale = _UnsupportedLocale;
+var EventAggregateField = {
+  EventTypeCategory: "eventTypeCategory"
+};
+var EventStatusCode = {
+  CLOSED: "closed",
+  OPEN: "open",
+  UPCOMING: "upcoming"
+};
+var EventTypeCategory = {
+  ACCOUNT_NOTIFICATION: "accountNotification",
+  INVESTIGATION: "investigation",
+  ISSUE: "issue",
+  SCHEDULED_CHANGE: "scheduledChange"
+};
+var _ConcurrentModificationException = class _ConcurrentModificationException extends HealthServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConcurrentModificationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConcurrentModificationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConcurrentModificationException.prototype);
+  }
+};
+__name(_ConcurrentModificationException, "ConcurrentModificationException");
+var ConcurrentModificationException = _ConcurrentModificationException;
+
+// src/protocols/Aws_json1_1.ts
+var se_DescribeAffectedAccountsForOrganizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeAffectedAccountsForOrganization");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeAffectedAccountsForOrganizationCommand");
+var se_DescribeAffectedEntitiesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeAffectedEntities");
+  let body;
+  body = JSON.stringify(se_DescribeAffectedEntitiesRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeAffectedEntitiesCommand");
+var se_DescribeAffectedEntitiesForOrganizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeAffectedEntitiesForOrganization");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeAffectedEntitiesForOrganizationCommand");
+var se_DescribeEntityAggregatesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeEntityAggregates");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeEntityAggregatesCommand");
+var se_DescribeEntityAggregatesForOrganizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeEntityAggregatesForOrganization");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeEntityAggregatesForOrganizationCommand");
+var se_DescribeEventAggregatesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeEventAggregates");
+  let body;
+  body = JSON.stringify(se_DescribeEventAggregatesRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeEventAggregatesCommand");
+var se_DescribeEventDetailsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeEventDetails");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeEventDetailsCommand");
+var se_DescribeEventDetailsForOrganizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeEventDetailsForOrganization");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeEventDetailsForOrganizationCommand");
+var se_DescribeEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeEvents");
+  let body;
+  body = JSON.stringify(se_DescribeEventsRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeEventsCommand");
+var se_DescribeEventsForOrganizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeEventsForOrganization");
+  let body;
+  body = JSON.stringify(se_DescribeEventsForOrganizationRequest(input, context));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeEventsForOrganizationCommand");
+var se_DescribeEventTypesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeEventTypes");
+  let body;
+  body = JSON.stringify((0, import_smithy_client._json)(input));
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeEventTypesCommand");
+var se_DescribeHealthServiceStatusForOrganizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DescribeHealthServiceStatusForOrganization");
+  const body = "{}";
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DescribeHealthServiceStatusForOrganizationCommand");
+var se_DisableHealthServiceAccessForOrganizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("DisableHealthServiceAccessForOrganization");
+  const body = "{}";
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_DisableHealthServiceAccessForOrganizationCommand");
+var se_EnableHealthServiceAccessForOrganizationCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const headers = sharedHeaders("EnableHealthServiceAccessForOrganization");
+  const body = "{}";
+  return buildHttpRpcRequest(context, headers, "/", void 0, body);
+}, "se_EnableHealthServiceAccessForOrganizationCommand");
+var de_DescribeAffectedAccountsForOrganizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeAffectedAccountsForOrganizationCommandError(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_DescribeAffectedAccountsForOrganizationCommand");
+var de_DescribeAffectedAccountsForOrganizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidPaginationToken":
+    case "com.amazonaws.health#InvalidPaginationToken":
+      throw await de_InvalidPaginationTokenRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeAffectedAccountsForOrganizationCommandError");
+var de_DescribeAffectedEntitiesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeAffectedEntitiesCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeAffectedEntitiesResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeAffectedEntitiesCommand");
+var de_DescribeAffectedEntitiesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidPaginationToken":
+    case "com.amazonaws.health#InvalidPaginationToken":
+      throw await de_InvalidPaginationTokenRes(parsedOutput, context);
+    case "UnsupportedLocale":
+    case "com.amazonaws.health#UnsupportedLocale":
+      throw await de_UnsupportedLocaleRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeAffectedEntitiesCommandError");
+var de_DescribeAffectedEntitiesForOrganizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeAffectedEntitiesForOrganizationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeAffectedEntitiesForOrganizationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeAffectedEntitiesForOrganizationCommand");
+var de_DescribeAffectedEntitiesForOrganizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidPaginationToken":
+    case "com.amazonaws.health#InvalidPaginationToken":
+      throw await de_InvalidPaginationTokenRes(parsedOutput, context);
+    case "UnsupportedLocale":
+    case "com.amazonaws.health#UnsupportedLocale":
+      throw await de_UnsupportedLocaleRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeAffectedEntitiesForOrganizationCommandError");
+var de_DescribeEntityAggregatesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEntityAggregatesCommandError(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_DescribeEntityAggregatesCommand");
+var de_DescribeEntityAggregatesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  const parsedBody = parsedOutput.body;
+  return throwDefaultError({
+    output,
+    parsedBody,
+    errorCode
+  });
+}, "de_DescribeEntityAggregatesCommandError");
+var de_DescribeEntityAggregatesForOrganizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEntityAggregatesForOrganizationCommandError(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_DescribeEntityAggregatesForOrganizationCommand");
+var de_DescribeEntityAggregatesForOrganizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  const parsedBody = parsedOutput.body;
+  return throwDefaultError({
+    output,
+    parsedBody,
+    errorCode
+  });
+}, "de_DescribeEntityAggregatesForOrganizationCommandError");
+var de_DescribeEventAggregatesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEventAggregatesCommandError(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_DescribeEventAggregatesCommand");
+var de_DescribeEventAggregatesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidPaginationToken":
+    case "com.amazonaws.health#InvalidPaginationToken":
+      throw await de_InvalidPaginationTokenRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeEventAggregatesCommandError");
+var de_DescribeEventDetailsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEventDetailsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeEventDetailsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeEventDetailsCommand");
+var de_DescribeEventDetailsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "UnsupportedLocale":
+    case "com.amazonaws.health#UnsupportedLocale":
+      throw await de_UnsupportedLocaleRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeEventDetailsCommandError");
+var de_DescribeEventDetailsForOrganizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEventDetailsForOrganizationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeEventDetailsForOrganizationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeEventDetailsForOrganizationCommand");
+var de_DescribeEventDetailsForOrganizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "UnsupportedLocale":
+    case "com.amazonaws.health#UnsupportedLocale":
+      throw await de_UnsupportedLocaleRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeEventDetailsForOrganizationCommandError");
+var de_DescribeEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEventsCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeEventsResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeEventsCommand");
+var de_DescribeEventsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidPaginationToken":
+    case "com.amazonaws.health#InvalidPaginationToken":
+      throw await de_InvalidPaginationTokenRes(parsedOutput, context);
+    case "UnsupportedLocale":
+    case "com.amazonaws.health#UnsupportedLocale":
+      throw await de_UnsupportedLocaleRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeEventsCommandError");
+var de_DescribeEventsForOrganizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEventsForOrganizationCommandError(output, context);
+  }
+  const data = await parseBody(output.body, context);
+  let contents = {};
+  contents = de_DescribeEventsForOrganizationResponse(data, context);
+  const response = {
+    $metadata: deserializeMetadata(output),
+    ...contents
+  };
+  return response;
+}, "de_DescribeEventsForOrganizationCommand");
+var de_DescribeEventsForOrganizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidPaginationToken":
+    case "com.amazonaws.health#InvalidPaginationToken":
+      throw await de_InvalidPaginationTokenRes(parsedOutput, context);
+    case "UnsupportedLocale":
+    case "com.amazonaws.health#UnsupportedLocale":
+      throw await de_UnsupportedLocaleRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeEventsForOrganizationCommandError");
+var de_DescribeEventTypesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeEventTypesCommandError(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_DescribeEventTypesCommand");
+var de_DescribeEventTypesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "InvalidPaginationToken":
+    case "com.amazonaws.health#InvalidPaginationToken":
+      throw await de_InvalidPaginationTokenRes(parsedOutput, context);
+    case "UnsupportedLocale":
+    case "com.amazonaws.health#UnsupportedLocale":
+      throw await de_UnsupportedLocaleRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DescribeEventTypesCommandError");
+var de_DescribeHealthServiceStatusForOrganizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DescribeHealthServiceStatusForOrganizationCommandError(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_DescribeHealthServiceStatusForOrganizationCommand");
+var de_DescribeHealthServiceStatusForOrganizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  const parsedBody = parsedOutput.body;
+  return throwDefaultError({
+    output,
+    parsedBody,
+    errorCode
+  });
+}, "de_DescribeHealthServiceStatusForOrganizationCommandError");
+var de_DisableHealthServiceAccessForOrganizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_DisableHealthServiceAccessForOrganizationCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_DisableHealthServiceAccessForOrganizationCommand");
+var de_DisableHealthServiceAccessForOrganizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.health#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DisableHealthServiceAccessForOrganizationCommandError");
+var de_EnableHealthServiceAccessForOrganizationCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode >= 300) {
+    return de_EnableHealthServiceAccessForOrganizationCommandError(output, context);
+  }
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  const response = {
+    $metadata: deserializeMetadata(output)
+  };
+  return response;
+}, "de_EnableHealthServiceAccessForOrganizationCommand");
+var de_EnableHealthServiceAccessForOrganizationCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "ConcurrentModificationException":
+    case "com.amazonaws.health#ConcurrentModificationException":
+      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_EnableHealthServiceAccessForOrganizationCommandError");
+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_InvalidPaginationTokenRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new InvalidPaginationToken({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_InvalidPaginationTokenRes");
+var de_UnsupportedLocaleRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const body = parsedOutput.body;
+  const deserialized = (0, import_smithy_client._json)(body);
+  const exception = new UnsupportedLocale({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...deserialized
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, body);
+}, "de_UnsupportedLocaleRes");
+var se_DateTimeRange = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    from: (_) => Math.round(_.getTime() / 1e3),
+    to: (_) => Math.round(_.getTime() / 1e3)
+  });
+}, "se_DateTimeRange");
+var se_dateTimeRangeList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_DateTimeRange(entry, context);
+  });
+}, "se_dateTimeRangeList");
+var se_DescribeAffectedEntitiesRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    filter: (_) => se_EntityFilter(_, context),
+    locale: [],
+    maxResults: [],
+    nextToken: []
+  });
+}, "se_DescribeAffectedEntitiesRequest");
+var se_DescribeEventAggregatesRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    aggregateField: [],
+    filter: (_) => se_EventFilter(_, context),
+    maxResults: [],
+    nextToken: []
+  });
+}, "se_DescribeEventAggregatesRequest");
+var se_DescribeEventsForOrganizationRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    filter: (_) => se_OrganizationEventFilter(_, context),
+    locale: [],
+    maxResults: [],
+    nextToken: []
+  });
+}, "se_DescribeEventsForOrganizationRequest");
+var se_DescribeEventsRequest = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    filter: (_) => se_EventFilter(_, context),
+    locale: [],
+    maxResults: [],
+    nextToken: []
+  });
+}, "se_DescribeEventsRequest");
+var se_EntityFilter = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    entityArns: import_smithy_client._json,
+    entityValues: import_smithy_client._json,
+    eventArns: import_smithy_client._json,
+    lastUpdatedTimes: (_) => se_dateTimeRangeList(_, context),
+    statusCodes: import_smithy_client._json,
+    tags: import_smithy_client._json
+  });
+}, "se_EntityFilter");
+var se_EventFilter = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    availabilityZones: import_smithy_client._json,
+    endTimes: (_) => se_dateTimeRangeList(_, context),
+    entityArns: import_smithy_client._json,
+    entityValues: import_smithy_client._json,
+    eventArns: import_smithy_client._json,
+    eventStatusCodes: import_smithy_client._json,
+    eventTypeCategories: import_smithy_client._json,
+    eventTypeCodes: import_smithy_client._json,
+    lastUpdatedTimes: (_) => se_dateTimeRangeList(_, context),
+    regions: import_smithy_client._json,
+    services: import_smithy_client._json,
+    startTimes: (_) => se_dateTimeRangeList(_, context),
+    tags: import_smithy_client._json
+  });
+}, "se_EventFilter");
+var se_OrganizationEventFilter = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    awsAccountIds: import_smithy_client._json,
+    endTime: (_) => se_DateTimeRange(_, context),
+    entityArns: import_smithy_client._json,
+    entityValues: import_smithy_client._json,
+    eventStatusCodes: import_smithy_client._json,
+    eventTypeCategories: import_smithy_client._json,
+    eventTypeCodes: import_smithy_client._json,
+    lastUpdatedTime: (_) => se_DateTimeRange(_, context),
+    regions: import_smithy_client._json,
+    services: import_smithy_client._json,
+    startTime: (_) => se_DateTimeRange(_, context)
+  });
+}, "se_OrganizationEventFilter");
+var de_AffectedEntity = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    awsAccountId: import_smithy_client.expectString,
+    entityArn: import_smithy_client.expectString,
+    entityUrl: import_smithy_client.expectString,
+    entityValue: import_smithy_client.expectString,
+    eventArn: import_smithy_client.expectString,
+    lastUpdatedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    statusCode: import_smithy_client.expectString,
+    tags: import_smithy_client._json
+  });
+}, "de_AffectedEntity");
+var de_DescribeAffectedEntitiesForOrganizationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    entities: (_) => de_EntityList(_, context),
+    failedSet: import_smithy_client._json,
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_DescribeAffectedEntitiesForOrganizationResponse");
+var de_DescribeAffectedEntitiesResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    entities: (_) => de_EntityList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_DescribeAffectedEntitiesResponse");
+var de_DescribeEventDetailsForOrganizationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    failedSet: import_smithy_client._json,
+    successfulSet: (_) => de_DescribeEventDetailsForOrganizationSuccessfulSet(_, context)
+  });
+}, "de_DescribeEventDetailsForOrganizationResponse");
+var de_DescribeEventDetailsForOrganizationSuccessfulSet = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_OrganizationEventDetails(entry, context);
+  });
+  return retVal;
+}, "de_DescribeEventDetailsForOrganizationSuccessfulSet");
+var de_DescribeEventDetailsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    failedSet: import_smithy_client._json,
+    successfulSet: (_) => de_DescribeEventDetailsSuccessfulSet(_, context)
+  });
+}, "de_DescribeEventDetailsResponse");
+var de_DescribeEventDetailsSuccessfulSet = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_EventDetails(entry, context);
+  });
+  return retVal;
+}, "de_DescribeEventDetailsSuccessfulSet");
+var de_DescribeEventsForOrganizationResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    events: (_) => de_OrganizationEventList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_DescribeEventsForOrganizationResponse");
+var de_DescribeEventsResponse = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    events: (_) => de_EventList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+}, "de_DescribeEventsResponse");
+var de_EntityList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_AffectedEntity(entry, context);
+  });
+  return retVal;
+}, "de_EntityList");
+var de_Event = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    availabilityZone: import_smithy_client.expectString,
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    eventScopeCode: import_smithy_client.expectString,
+    eventTypeCategory: import_smithy_client.expectString,
+    eventTypeCode: import_smithy_client.expectString,
+    lastUpdatedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    region: import_smithy_client.expectString,
+    service: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    statusCode: import_smithy_client.expectString
+  });
+}, "de_Event");
+var de_EventDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    event: (_) => de_Event(_, context),
+    eventDescription: import_smithy_client._json,
+    eventMetadata: import_smithy_client._json
+  });
+}, "de_EventDetails");
+var de_EventList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Event(entry, context);
+  });
+  return retVal;
+}, "de_EventList");
+var de_OrganizationEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    eventScopeCode: import_smithy_client.expectString,
+    eventTypeCategory: import_smithy_client.expectString,
+    eventTypeCode: import_smithy_client.expectString,
+    lastUpdatedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    region: import_smithy_client.expectString,
+    service: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    statusCode: import_smithy_client.expectString
+  });
+}, "de_OrganizationEvent");
+var de_OrganizationEventDetails = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    awsAccountId: import_smithy_client.expectString,
+    event: (_) => de_Event(_, context),
+    eventDescription: import_smithy_client._json,
+    eventMetadata: import_smithy_client._json
+  });
+}, "de_OrganizationEventDetails");
+var de_OrganizationEventList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_OrganizationEvent(entry, context);
+  });
+  return retVal;
+}, "de_OrganizationEventList");
+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)(HealthServiceException);
+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": `AWSHealth_20160804.${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/DescribeAffectedAccountsForOrganizationCommand.ts
+var _DescribeAffectedAccountsForOrganizationCommand = class _DescribeAffectedAccountsForOrganizationCommand 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("AWSHealth_20160804", "DescribeAffectedAccountsForOrganization", {}).n("HealthClient", "DescribeAffectedAccountsForOrganizationCommand").f(void 0, void 0).ser(se_DescribeAffectedAccountsForOrganizationCommand).de(de_DescribeAffectedAccountsForOrganizationCommand).build() {
+};
+__name(_DescribeAffectedAccountsForOrganizationCommand, "DescribeAffectedAccountsForOrganizationCommand");
+var DescribeAffectedAccountsForOrganizationCommand = _DescribeAffectedAccountsForOrganizationCommand;
+
+// src/commands/DescribeAffectedEntitiesCommand.ts
+
+
+
+
+var _DescribeAffectedEntitiesCommand = class _DescribeAffectedEntitiesCommand 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("AWSHealth_20160804", "DescribeAffectedEntities", {}).n("HealthClient", "DescribeAffectedEntitiesCommand").f(void 0, void 0).ser(se_DescribeAffectedEntitiesCommand).de(de_DescribeAffectedEntitiesCommand).build() {
+};
+__name(_DescribeAffectedEntitiesCommand, "DescribeAffectedEntitiesCommand");
+var DescribeAffectedEntitiesCommand = _DescribeAffectedEntitiesCommand;
+
+// src/commands/DescribeAffectedEntitiesForOrganizationCommand.ts
+
+
+
+
+var _DescribeAffectedEntitiesForOrganizationCommand = class _DescribeAffectedEntitiesForOrganizationCommand 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("AWSHealth_20160804", "DescribeAffectedEntitiesForOrganization", {}).n("HealthClient", "DescribeAffectedEntitiesForOrganizationCommand").f(void 0, void 0).ser(se_DescribeAffectedEntitiesForOrganizationCommand).de(de_DescribeAffectedEntitiesForOrganizationCommand).build() {
+};
+__name(_DescribeAffectedEntitiesForOrganizationCommand, "DescribeAffectedEntitiesForOrganizationCommand");
+var DescribeAffectedEntitiesForOrganizationCommand = _DescribeAffectedEntitiesForOrganizationCommand;
+
+// src/commands/DescribeEntityAggregatesCommand.ts
+
+
+
+
+var _DescribeEntityAggregatesCommand = class _DescribeEntityAggregatesCommand 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("AWSHealth_20160804", "DescribeEntityAggregates", {}).n("HealthClient", "DescribeEntityAggregatesCommand").f(void 0, void 0).ser(se_DescribeEntityAggregatesCommand).de(de_DescribeEntityAggregatesCommand).build() {
+};
+__name(_DescribeEntityAggregatesCommand, "DescribeEntityAggregatesCommand");
+var DescribeEntityAggregatesCommand = _DescribeEntityAggregatesCommand;
+
+// src/commands/DescribeEntityAggregatesForOrganizationCommand.ts
+
+
+
+
+var _DescribeEntityAggregatesForOrganizationCommand = class _DescribeEntityAggregatesForOrganizationCommand 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("AWSHealth_20160804", "DescribeEntityAggregatesForOrganization", {}).n("HealthClient", "DescribeEntityAggregatesForOrganizationCommand").f(void 0, void 0).ser(se_DescribeEntityAggregatesForOrganizationCommand).de(de_DescribeEntityAggregatesForOrganizationCommand).build() {
+};
+__name(_DescribeEntityAggregatesForOrganizationCommand, "DescribeEntityAggregatesForOrganizationCommand");
+var DescribeEntityAggregatesForOrganizationCommand = _DescribeEntityAggregatesForOrganizationCommand;
+
+// src/commands/DescribeEventAggregatesCommand.ts
+
+
+
+
+var _DescribeEventAggregatesCommand = class _DescribeEventAggregatesCommand 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("AWSHealth_20160804", "DescribeEventAggregates", {}).n("HealthClient", "DescribeEventAggregatesCommand").f(void 0, void 0).ser(se_DescribeEventAggregatesCommand).de(de_DescribeEventAggregatesCommand).build() {
+};
+__name(_DescribeEventAggregatesCommand, "DescribeEventAggregatesCommand");
+var DescribeEventAggregatesCommand = _DescribeEventAggregatesCommand;
+
+// src/commands/DescribeEventDetailsCommand.ts
+
+
+
+
+var _DescribeEventDetailsCommand = class _DescribeEventDetailsCommand 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("AWSHealth_20160804", "DescribeEventDetails", {}).n("HealthClient", "DescribeEventDetailsCommand").f(void 0, void 0).ser(se_DescribeEventDetailsCommand).de(de_DescribeEventDetailsCommand).build() {
+};
+__name(_DescribeEventDetailsCommand, "DescribeEventDetailsCommand");
+var DescribeEventDetailsCommand = _DescribeEventDetailsCommand;
+
+// src/commands/DescribeEventDetailsForOrganizationCommand.ts
+
+
+
+
+var _DescribeEventDetailsForOrganizationCommand = class _DescribeEventDetailsForOrganizationCommand 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("AWSHealth_20160804", "DescribeEventDetailsForOrganization", {}).n("HealthClient", "DescribeEventDetailsForOrganizationCommand").f(void 0, void 0).ser(se_DescribeEventDetailsForOrganizationCommand).de(de_DescribeEventDetailsForOrganizationCommand).build() {
+};
+__name(_DescribeEventDetailsForOrganizationCommand, "DescribeEventDetailsForOrganizationCommand");
+var DescribeEventDetailsForOrganizationCommand = _DescribeEventDetailsForOrganizationCommand;
+
+// src/commands/DescribeEventsCommand.ts
+
+
+
+
+var _DescribeEventsCommand = class _DescribeEventsCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("AWSHealth_20160804", "DescribeEvents", {}).n("HealthClient", "DescribeEventsCommand").f(void 0, void 0).ser(se_DescribeEventsCommand).de(de_DescribeEventsCommand).build() {
+};
+__name(_DescribeEventsCommand, "DescribeEventsCommand");
+var DescribeEventsCommand = _DescribeEventsCommand;
+
+// src/commands/DescribeEventsForOrganizationCommand.ts
+
+
+
+
+var _DescribeEventsForOrganizationCommand = class _DescribeEventsForOrganizationCommand 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("AWSHealth_20160804", "DescribeEventsForOrganization", {}).n("HealthClient", "DescribeEventsForOrganizationCommand").f(void 0, void 0).ser(se_DescribeEventsForOrganizationCommand).de(de_DescribeEventsForOrganizationCommand).build() {
+};
+__name(_DescribeEventsForOrganizationCommand, "DescribeEventsForOrganizationCommand");
+var DescribeEventsForOrganizationCommand = _DescribeEventsForOrganizationCommand;
+
+// src/commands/DescribeEventTypesCommand.ts
+
+
+
+
+var _DescribeEventTypesCommand = class _DescribeEventTypesCommand 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("AWSHealth_20160804", "DescribeEventTypes", {}).n("HealthClient", "DescribeEventTypesCommand").f(void 0, void 0).ser(se_DescribeEventTypesCommand).de(de_DescribeEventTypesCommand).build() {
+};
+__name(_DescribeEventTypesCommand, "DescribeEventTypesCommand");
+var DescribeEventTypesCommand = _DescribeEventTypesCommand;
+
+// src/commands/DescribeHealthServiceStatusForOrganizationCommand.ts
+
+
+
+
+var _DescribeHealthServiceStatusForOrganizationCommand = class _DescribeHealthServiceStatusForOrganizationCommand 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("AWSHealth_20160804", "DescribeHealthServiceStatusForOrganization", {}).n("HealthClient", "DescribeHealthServiceStatusForOrganizationCommand").f(void 0, void 0).ser(se_DescribeHealthServiceStatusForOrganizationCommand).de(de_DescribeHealthServiceStatusForOrganizationCommand).build() {
+};
+__name(_DescribeHealthServiceStatusForOrganizationCommand, "DescribeHealthServiceStatusForOrganizationCommand");
+var DescribeHealthServiceStatusForOrganizationCommand = _DescribeHealthServiceStatusForOrganizationCommand;
+
+// src/commands/DisableHealthServiceAccessForOrganizationCommand.ts
+
+
+
+
+var _DisableHealthServiceAccessForOrganizationCommand = class _DisableHealthServiceAccessForOrganizationCommand 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("AWSHealth_20160804", "DisableHealthServiceAccessForOrganization", {}).n("HealthClient", "DisableHealthServiceAccessForOrganizationCommand").f(void 0, void 0).ser(se_DisableHealthServiceAccessForOrganizationCommand).de(de_DisableHealthServiceAccessForOrganizationCommand).build() {
+};
+__name(_DisableHealthServiceAccessForOrganizationCommand, "DisableHealthServiceAccessForOrganizationCommand");
+var DisableHealthServiceAccessForOrganizationCommand = _DisableHealthServiceAccessForOrganizationCommand;
+
+// src/commands/EnableHealthServiceAccessForOrganizationCommand.ts
+
+
+
+
+var _EnableHealthServiceAccessForOrganizationCommand = class _EnableHealthServiceAccessForOrganizationCommand 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("AWSHealth_20160804", "EnableHealthServiceAccessForOrganization", {}).n("HealthClient", "EnableHealthServiceAccessForOrganizationCommand").f(void 0, void 0).ser(se_EnableHealthServiceAccessForOrganizationCommand).de(de_EnableHealthServiceAccessForOrganizationCommand).build() {
+};
+__name(_EnableHealthServiceAccessForOrganizationCommand, "EnableHealthServiceAccessForOrganizationCommand");
+var EnableHealthServiceAccessForOrganizationCommand = _EnableHealthServiceAccessForOrganizationCommand;
+
+// src/Health.ts
+var commands = {
+  DescribeAffectedAccountsForOrganizationCommand,
+  DescribeAffectedEntitiesCommand,
+  DescribeAffectedEntitiesForOrganizationCommand,
+  DescribeEntityAggregatesCommand,
+  DescribeEntityAggregatesForOrganizationCommand,
+  DescribeEventAggregatesCommand,
+  DescribeEventDetailsCommand,
+  DescribeEventDetailsForOrganizationCommand,
+  DescribeEventsCommand,
+  DescribeEventsForOrganizationCommand,
+  DescribeEventTypesCommand,
+  DescribeHealthServiceStatusForOrganizationCommand,
+  DisableHealthServiceAccessForOrganizationCommand,
+  EnableHealthServiceAccessForOrganizationCommand
+};
+var _Health = class _Health extends HealthClient {
+};
+__name(_Health, "Health");
+var Health = _Health;
+(0, import_smithy_client.createAggregatedClient)(commands, Health);
+
+// src/pagination/DescribeAffectedAccountsForOrganizationPaginator.ts
+var import_core = require("@smithy/core");
+var paginateDescribeAffectedAccountsForOrganization = (0, import_core.createPaginator)(HealthClient, DescribeAffectedAccountsForOrganizationCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribeAffectedEntitiesForOrganizationPaginator.ts
+
+var paginateDescribeAffectedEntitiesForOrganization = (0, import_core.createPaginator)(HealthClient, DescribeAffectedEntitiesForOrganizationCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribeAffectedEntitiesPaginator.ts
+
+var paginateDescribeAffectedEntities = (0, import_core.createPaginator)(HealthClient, DescribeAffectedEntitiesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribeEventAggregatesPaginator.ts
+
+var paginateDescribeEventAggregates = (0, import_core.createPaginator)(HealthClient, DescribeEventAggregatesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribeEventTypesPaginator.ts
+
+var paginateDescribeEventTypes = (0, import_core.createPaginator)(HealthClient, DescribeEventTypesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribeEventsForOrganizationPaginator.ts
+
+var paginateDescribeEventsForOrganization = (0, import_core.createPaginator)(HealthClient, DescribeEventsForOrganizationCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/DescribeEventsPaginator.ts
+
+var paginateDescribeEvents = (0, import_core.createPaginator)(HealthClient, DescribeEventsCommand, "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 = {
+  ConcurrentModificationException,
+  DescribeAffectedAccountsForOrganizationCommand,
+  DescribeAffectedEntitiesCommand,
+  DescribeAffectedEntitiesForOrganizationCommand,
+  DescribeEntityAggregatesCommand,
+  DescribeEntityAggregatesForOrganizationCommand,
+  DescribeEventAggregatesCommand,
+  DescribeEventDetailsCommand,
+  DescribeEventDetailsForOrganizationCommand,
+  DescribeEventTypesCommand,
+  DescribeEventsCommand,
+  DescribeEventsForOrganizationCommand,
+  DescribeHealthServiceStatusForOrganizationCommand,
+  DisableHealthServiceAccessForOrganizationCommand,
+  EnableHealthServiceAccessForOrganizationCommand,
+  EntityStatusCode,
+  EventAggregateField,
+  EventScopeCode,
+  EventStatusCode,
+  EventTypeCategory,
+  Health,
+  HealthClient,
+  HealthServiceException,
+  InvalidPaginationToken,
+  UnsupportedLocale,
+  __Client,
+  paginateDescribeAffectedAccountsForOrganization,
+  paginateDescribeAffectedEntities,
+  paginateDescribeAffectedEntitiesForOrganization,
+  paginateDescribeEventAggregates,
+  paginateDescribeEventTypes,
+  paginateDescribeEvents,
+  paginateDescribeEventsForOrganization
+});
+