@aws-sdk/client-ssm-incidents 3.490.0 → 3.496.0

package/dist-cjs/index.js

@@ -1,13 +1,3542 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SSMIncidentsServiceException = void 0;
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./SSMIncidentsClient"), exports);
-tslib_1.__exportStar(require("./SSMIncidents"), exports);
-tslib_1.__exportStar(require("./commands"), exports);
-tslib_1.__exportStar(require("./pagination"), exports);
-tslib_1.__exportStar(require("./waiters"), exports);
-tslib_1.__exportStar(require("./models"), exports);
-require("@aws-sdk/util-endpoints");
-var SSMIncidentsServiceException_1 = require("./models/SSMIncidentsServiceException");
-Object.defineProperty(exports, "SSMIncidentsServiceException", { enumerable: true, get: function () { return SSMIncidentsServiceException_1.SSMIncidentsServiceException; } });
+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, {
+  AccessDeniedException: () => AccessDeniedException,
+  Action: () => Action,
+  AttributeValueList: () => AttributeValueList,
+  AutomationExecution: () => AutomationExecution,
+  BatchGetIncidentFindingsCommand: () => BatchGetIncidentFindingsCommand,
+  ChatChannel: () => ChatChannel,
+  Condition: () => Condition,
+  ConflictException: () => ConflictException,
+  CreateReplicationSetCommand: () => CreateReplicationSetCommand,
+  CreateResponsePlanCommand: () => CreateResponsePlanCommand,
+  CreateTimelineEventCommand: () => CreateTimelineEventCommand,
+  DeleteIncidentRecordCommand: () => DeleteIncidentRecordCommand,
+  DeleteReplicationSetCommand: () => DeleteReplicationSetCommand,
+  DeleteResourcePolicyCommand: () => DeleteResourcePolicyCommand,
+  DeleteResponsePlanCommand: () => DeleteResponsePlanCommand,
+  DeleteTimelineEventCommand: () => DeleteTimelineEventCommand,
+  DynamicSsmParameterValue: () => DynamicSsmParameterValue,
+  EventReference: () => EventReference,
+  FindingDetails: () => FindingDetails,
+  GetIncidentRecordCommand: () => GetIncidentRecordCommand,
+  GetReplicationSetCommand: () => GetReplicationSetCommand,
+  GetResourcePoliciesCommand: () => GetResourcePoliciesCommand,
+  GetResponsePlanCommand: () => GetResponsePlanCommand,
+  GetTimelineEventCommand: () => GetTimelineEventCommand,
+  IncidentRecordStatus: () => IncidentRecordStatus,
+  Integration: () => Integration,
+  InternalServerException: () => InternalServerException,
+  ItemType: () => ItemType,
+  ItemValue: () => ItemValue,
+  ListIncidentFindingsCommand: () => ListIncidentFindingsCommand,
+  ListIncidentRecordsCommand: () => ListIncidentRecordsCommand,
+  ListRelatedItemsCommand: () => ListRelatedItemsCommand,
+  ListReplicationSetsCommand: () => ListReplicationSetsCommand,
+  ListResponsePlansCommand: () => ListResponsePlansCommand,
+  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
+  ListTimelineEventsCommand: () => ListTimelineEventsCommand,
+  NotificationTargetItem: () => NotificationTargetItem,
+  PutResourcePolicyCommand: () => PutResourcePolicyCommand,
+  RegionStatus: () => RegionStatus,
+  RelatedItemsUpdate: () => RelatedItemsUpdate,
+  ReplicationSetStatus: () => ReplicationSetStatus,
+  ResourceNotFoundException: () => ResourceNotFoundException,
+  ResourceType: () => ResourceType,
+  SSMIncidents: () => SSMIncidents,
+  SSMIncidentsClient: () => SSMIncidentsClient,
+  SSMIncidentsServiceException: () => SSMIncidentsServiceException,
+  ServiceCode: () => ServiceCode,
+  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
+  SortOrder: () => SortOrder,
+  SsmTargetAccount: () => SsmTargetAccount,
+  StartIncidentCommand: () => StartIncidentCommand,
+  TagResourceCommand: () => TagResourceCommand,
+  ThrottlingException: () => ThrottlingException,
+  TimelineEventSort: () => TimelineEventSort,
+  UntagResourceCommand: () => UntagResourceCommand,
+  UpdateDeletionProtectionCommand: () => UpdateDeletionProtectionCommand,
+  UpdateIncidentRecordCommand: () => UpdateIncidentRecordCommand,
+  UpdateRelatedItemsCommand: () => UpdateRelatedItemsCommand,
+  UpdateReplicationSetAction: () => UpdateReplicationSetAction,
+  UpdateReplicationSetCommand: () => UpdateReplicationSetCommand,
+  UpdateResponsePlanCommand: () => UpdateResponsePlanCommand,
+  UpdateTimelineEventCommand: () => UpdateTimelineEventCommand,
+  ValidationException: () => ValidationException,
+  VariableType: () => VariableType,
+  __Client: () => import_smithy_client.Client,
+  paginateGetResourcePolicies: () => paginateGetResourcePolicies,
+  paginateListIncidentFindings: () => paginateListIncidentFindings,
+  paginateListIncidentRecords: () => paginateListIncidentRecords,
+  paginateListRelatedItems: () => paginateListRelatedItems,
+  paginateListReplicationSets: () => paginateListReplicationSets,
+  paginateListResponsePlans: () => paginateListResponsePlans,
+  paginateListTimelineEvents: () => paginateListTimelineEvents,
+  waitForWaitForReplicationSetActive: () => waitForWaitForReplicationSetActive,
+  waitForWaitForReplicationSetDeleted: () => waitForWaitForReplicationSetDeleted,
+  waitUntilWaitForReplicationSetActive: () => waitUntilWaitForReplicationSetActive,
+  waitUntilWaitForReplicationSetDeleted: () => waitUntilWaitForReplicationSetDeleted
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/SSMIncidentsClient.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: "ssm-incidents"
+  };
+}, "resolveClientEndpointParameters");
+var commonParams = {
+  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+  Endpoint: { type: "builtInParams", name: "endpoint" },
+  Region: { type: "builtInParams", name: "region" },
+  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
+};
+
+// src/SSMIncidentsClient.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/SSMIncidentsClient.ts
+var _SSMIncidentsClient = class _SSMIncidentsClient 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(_SSMIncidentsClient, "SSMIncidentsClient");
+var SSMIncidentsClient = _SSMIncidentsClient;
+
+// src/SSMIncidents.ts
+
+
+// src/commands/BatchGetIncidentFindingsCommand.ts
+
+var import_middleware_serde = require("@smithy/middleware-serde");
+
+var import_types = require("@smithy/types");
+
+// src/protocols/Aws_restJson1.ts
+var import_core = require("@aws-sdk/core");
+var import_core2 = require("@smithy/core");
+
+var import_uuid = require("uuid");
+
+// src/models/SSMIncidentsServiceException.ts
+
+var _SSMIncidentsServiceException = class _SSMIncidentsServiceException extends import_smithy_client.ServiceException {
+  /**
+   * @internal
+   */
+  constructor(options) {
+    super(options);
+    Object.setPrototypeOf(this, _SSMIncidentsServiceException.prototype);
+  }
+};
+__name(_SSMIncidentsServiceException, "SSMIncidentsServiceException");
+var SSMIncidentsServiceException = _SSMIncidentsServiceException;
+
+// src/models/models_0.ts
+var _AccessDeniedException = class _AccessDeniedException extends SSMIncidentsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "AccessDeniedException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "AccessDeniedException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
+  }
+};
+__name(_AccessDeniedException, "AccessDeniedException");
+var AccessDeniedException = _AccessDeniedException;
+var VariableType = {
+  INCIDENT_RECORD_ARN: "INCIDENT_RECORD_ARN",
+  INVOLVED_RESOURCES: "INVOLVED_RESOURCES"
+};
+var DynamicSsmParameterValue;
+((DynamicSsmParameterValue3) => {
+  DynamicSsmParameterValue3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.variable !== void 0)
+      return visitor.variable(value.variable);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(DynamicSsmParameterValue || (DynamicSsmParameterValue = {}));
+var SsmTargetAccount = {
+  IMPACTED_ACCOUNT: "IMPACTED_ACCOUNT",
+  RESPONSE_PLAN_OWNER_ACCOUNT: "RESPONSE_PLAN_OWNER_ACCOUNT"
+};
+var Action;
+((Action3) => {
+  Action3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.ssmAutomation !== void 0)
+      return visitor.ssmAutomation(value.ssmAutomation);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Action || (Action = {}));
+var AttributeValueList;
+((AttributeValueList3) => {
+  AttributeValueList3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.stringValues !== void 0)
+      return visitor.stringValues(value.stringValues);
+    if (value.integerValues !== void 0)
+      return visitor.integerValues(value.integerValues);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(AttributeValueList || (AttributeValueList = {}));
+var AutomationExecution;
+((AutomationExecution2) => {
+  AutomationExecution2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.ssmExecutionArn !== void 0)
+      return visitor.ssmExecutionArn(value.ssmExecutionArn);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(AutomationExecution || (AutomationExecution = {}));
+var FindingDetails;
+((FindingDetails3) => {
+  FindingDetails3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.codeDeployDeployment !== void 0)
+      return visitor.codeDeployDeployment(value.codeDeployDeployment);
+    if (value.cloudFormationStackUpdate !== void 0)
+      return visitor.cloudFormationStackUpdate(value.cloudFormationStackUpdate);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(FindingDetails || (FindingDetails = {}));
+var _InternalServerException = class _InternalServerException extends SSMIncidentsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "InternalServerException",
+      $fault: "server",
+      ...opts
+    });
+    this.name = "InternalServerException";
+    this.$fault = "server";
+    Object.setPrototypeOf(this, _InternalServerException.prototype);
+  }
+};
+__name(_InternalServerException, "InternalServerException");
+var InternalServerException = _InternalServerException;
+var ResourceType = {
+  INCIDENT_RECORD: "INCIDENT_RECORD",
+  REPLICATION_SET: "REPLICATION_SET",
+  RESOURCE_POLICY: "RESOURCE_POLICY",
+  RESPONSE_PLAN: "RESPONSE_PLAN",
+  TIMELINE_EVENT: "TIMELINE_EVENT"
+};
+var _ResourceNotFoundException = class _ResourceNotFoundException extends SSMIncidentsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ResourceNotFoundException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ResourceNotFoundException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
+    this.resourceIdentifier = opts.resourceIdentifier;
+    this.resourceType = opts.resourceType;
+  }
+};
+__name(_ResourceNotFoundException, "ResourceNotFoundException");
+var ResourceNotFoundException = _ResourceNotFoundException;
+var ServiceCode = {
+  SSM_INCIDENTS: "ssm-incidents"
+};
+var _ThrottlingException = class _ThrottlingException extends SSMIncidentsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ThrottlingException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ThrottlingException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ThrottlingException.prototype);
+    this.serviceCode = opts.serviceCode;
+    this.quotaCode = opts.quotaCode;
+  }
+};
+__name(_ThrottlingException, "ThrottlingException");
+var ThrottlingException = _ThrottlingException;
+var _ValidationException = class _ValidationException extends SSMIncidentsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ValidationException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ValidationException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ValidationException.prototype);
+  }
+};
+__name(_ValidationException, "ValidationException");
+var ValidationException = _ValidationException;
+var ChatChannel;
+((ChatChannel3) => {
+  ChatChannel3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.empty !== void 0)
+      return visitor.empty(value.empty);
+    if (value.chatbotSns !== void 0)
+      return visitor.chatbotSns(value.chatbotSns);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ChatChannel || (ChatChannel = {}));
+var Condition;
+((Condition2) => {
+  Condition2.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.before !== void 0)
+      return visitor.before(value.before);
+    if (value.after !== void 0)
+      return visitor.after(value.after);
+    if (value.equals !== void 0)
+      return visitor.equals(value.equals);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Condition || (Condition = {}));
+var _ConflictException = class _ConflictException extends SSMIncidentsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ConflictException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ConflictException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ConflictException.prototype);
+    this.resourceIdentifier = opts.resourceIdentifier;
+    this.resourceType = opts.resourceType;
+    this.retryAfter = opts.retryAfter;
+  }
+};
+__name(_ConflictException, "ConflictException");
+var ConflictException = _ConflictException;
+var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends SSMIncidentsServiceException {
+  /**
+   * @internal
+   */
+  constructor(opts) {
+    super({
+      name: "ServiceQuotaExceededException",
+      $fault: "client",
+      ...opts
+    });
+    this.name = "ServiceQuotaExceededException";
+    this.$fault = "client";
+    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
+    this.resourceIdentifier = opts.resourceIdentifier;
+    this.resourceType = opts.resourceType;
+    this.serviceCode = opts.serviceCode;
+    this.quotaCode = opts.quotaCode;
+  }
+};
+__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
+var ServiceQuotaExceededException = _ServiceQuotaExceededException;
+var NotificationTargetItem;
+((NotificationTargetItem3) => {
+  NotificationTargetItem3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.snsTopicArn !== void 0)
+      return visitor.snsTopicArn(value.snsTopicArn);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(NotificationTargetItem || (NotificationTargetItem = {}));
+var Integration;
+((Integration3) => {
+  Integration3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.pagerDutyConfiguration !== void 0)
+      return visitor.pagerDutyConfiguration(value.pagerDutyConfiguration);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(Integration || (Integration = {}));
+var EventReference;
+((EventReference3) => {
+  EventReference3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.resource !== void 0)
+      return visitor.resource(value.resource);
+    if (value.relatedItemId !== void 0)
+      return visitor.relatedItemId(value.relatedItemId);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(EventReference || (EventReference = {}));
+var IncidentRecordStatus = {
+  OPEN: "OPEN",
+  RESOLVED: "RESOLVED"
+};
+var RegionStatus = {
+  /**
+   * All operations have completed successfully and the region is ready to use
+   */
+  ACTIVE: "ACTIVE",
+  /**
+   * The region is in the process of being created.
+   */
+  CREATING: "CREATING",
+  /**
+   * The region is in the process of being deleted.
+   */
+  DELETING: "DELETING",
+  /**
+   * The region is not healthy and we cannot automatically fix it.
+   */
+  FAILED: "FAILED"
+};
+var ReplicationSetStatus = {
+  /**
+   * All operations have completed successfully and the replication set is ready to use
+   */
+  ACTIVE: "ACTIVE",
+  /**
+   * Replication set is in the process of being created.
+   */
+  CREATING: "CREATING",
+  /**
+   * Replication set is in the process of being deleted.
+   */
+  DELETING: "DELETING",
+  /**
+   * Replication set is not healthy and we cannot fix it.
+   */
+  FAILED: "FAILED",
+  /**
+   * Replication set is in the process of being updated.
+   */
+  UPDATING: "UPDATING"
+};
+var ItemType = {
+  ANALYSIS: "ANALYSIS",
+  ATTACHMENT: "ATTACHMENT",
+  AUTOMATION: "AUTOMATION",
+  INCIDENT: "INCIDENT",
+  INVOLVED_RESOURCE: "INVOLVED_RESOURCE",
+  METRIC: "METRIC",
+  OTHER: "OTHER",
+  PARENT: "PARENT",
+  TASK: "TASK"
+};
+var ItemValue;
+((ItemValue3) => {
+  ItemValue3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.arn !== void 0)
+      return visitor.arn(value.arn);
+    if (value.url !== void 0)
+      return visitor.url(value.url);
+    if (value.metricDefinition !== void 0)
+      return visitor.metricDefinition(value.metricDefinition);
+    if (value.pagerDutyIncidentDetail !== void 0)
+      return visitor.pagerDutyIncidentDetail(value.pagerDutyIncidentDetail);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(ItemValue || (ItemValue = {}));
+var TimelineEventSort = {
+  EVENT_TIME: "EVENT_TIME"
+};
+var SortOrder = {
+  ASCENDING: "ASCENDING",
+  DESCENDING: "DESCENDING"
+};
+var RelatedItemsUpdate;
+((RelatedItemsUpdate3) => {
+  RelatedItemsUpdate3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.itemToAdd !== void 0)
+      return visitor.itemToAdd(value.itemToAdd);
+    if (value.itemToRemove !== void 0)
+      return visitor.itemToRemove(value.itemToRemove);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(RelatedItemsUpdate || (RelatedItemsUpdate = {}));
+var UpdateReplicationSetAction;
+((UpdateReplicationSetAction3) => {
+  UpdateReplicationSetAction3.visit = /* @__PURE__ */ __name((value, visitor) => {
+    if (value.addRegionAction !== void 0)
+      return visitor.addRegionAction(value.addRegionAction);
+    if (value.deleteRegionAction !== void 0)
+      return visitor.deleteRegionAction(value.deleteRegionAction);
+    return visitor._(value.$unknown[0], value.$unknown[1]);
+  }, "visit");
+})(UpdateReplicationSetAction || (UpdateReplicationSetAction = {}));
+
+// src/protocols/Aws_restJson1.ts
+var se_BatchGetIncidentFindingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/batchGetIncidentFindings");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      findingIds: (_) => (0, import_smithy_client._json)(_),
+      incidentRecordArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_BatchGetIncidentFindingsCommand");
+var se_CreateReplicationSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/createReplicationSet");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      regions: (_) => (0, import_smithy_client._json)(_),
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateReplicationSetCommand");
+var se_CreateResponsePlanCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/createResponsePlan");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      actions: (_) => (0, import_smithy_client._json)(_),
+      chatChannel: (_) => (0, import_smithy_client._json)(_),
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      displayName: [],
+      engagements: (_) => (0, import_smithy_client._json)(_),
+      incidentTemplate: (_) => (0, import_smithy_client._json)(_),
+      integrations: (_) => (0, import_smithy_client._json)(_),
+      name: [],
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateResponsePlanCommand");
+var se_CreateTimelineEventCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/createTimelineEvent");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      eventData: [],
+      eventReferences: (_) => (0, import_smithy_client._json)(_),
+      eventTime: (_) => Math.round(_.getTime() / 1e3),
+      eventType: [],
+      incidentRecordArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateTimelineEventCommand");
+var se_DeleteIncidentRecordCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/deleteIncidentRecord");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteIncidentRecordCommand");
+var se_DeleteReplicationSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/deleteReplicationSet");
+  const query = (0, import_smithy_client.map)({
+    [_a]: [, (0, import_smithy_client.expectNonNull)(input[_a], `arn`)]
+  });
+  let body;
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_DeleteReplicationSetCommand");
+var se_DeleteResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/deleteResourcePolicy");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      policyId: [],
+      resourceArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteResourcePolicyCommand");
+var se_DeleteResponsePlanCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/deleteResponsePlan");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteResponsePlanCommand");
+var se_DeleteTimelineEventCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/deleteTimelineEvent");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      eventId: [],
+      incidentRecordArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_DeleteTimelineEventCommand");
+var se_GetIncidentRecordCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/getIncidentRecord");
+  const query = (0, import_smithy_client.map)({
+    [_a]: [, (0, import_smithy_client.expectNonNull)(input[_a], `arn`)]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetIncidentRecordCommand");
+var se_GetReplicationSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/getReplicationSet");
+  const query = (0, import_smithy_client.map)({
+    [_a]: [, (0, import_smithy_client.expectNonNull)(input[_a], `arn`)]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetReplicationSetCommand");
+var se_GetResourcePoliciesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/getResourcePolicies");
+  const query = (0, import_smithy_client.map)({
+    [_rA]: [, (0, import_smithy_client.expectNonNull)(input[_rA], `resourceArn`)]
+  });
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetResourcePoliciesCommand");
+var se_GetResponsePlanCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/getResponsePlan");
+  const query = (0, import_smithy_client.map)({
+    [_a]: [, (0, import_smithy_client.expectNonNull)(input[_a], `arn`)]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetResponsePlanCommand");
+var se_GetTimelineEventCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/getTimelineEvent");
+  const query = (0, import_smithy_client.map)({
+    [_iRA]: [, (0, import_smithy_client.expectNonNull)(input[_iRA], `incidentRecordArn`)],
+    [_eI]: [, (0, import_smithy_client.expectNonNull)(input[_eI], `eventId`)]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_GetTimelineEventCommand");
+var se_ListIncidentFindingsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/listIncidentFindings");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      incidentRecordArn: [],
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListIncidentFindingsCommand");
+var se_ListIncidentRecordsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/listIncidentRecords");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      filters: (_) => se_FilterList(_, context),
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListIncidentRecordsCommand");
+var se_ListRelatedItemsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/listRelatedItems");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      incidentRecordArn: [],
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListRelatedItemsCommand");
+var se_ListReplicationSetsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/listReplicationSets");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListReplicationSetsCommand");
+var se_ListResponsePlansCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/listResponsePlans");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      maxResults: [],
+      nextToken: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListResponsePlansCommand");
+var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_ListTagsForResourceCommand");
+var se_ListTimelineEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/listTimelineEvents");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      filters: (_) => se_FilterList(_, context),
+      incidentRecordArn: [],
+      maxResults: [],
+      nextToken: [],
+      sortBy: [],
+      sortOrder: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_ListTimelineEventsCommand");
+var se_PutResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/putResourcePolicy");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      policy: [],
+      resourceArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_PutResourcePolicyCommand");
+var se_StartIncidentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/startIncident");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      impact: [],
+      relatedItems: (_) => (0, import_smithy_client._json)(_),
+      responsePlanArn: [],
+      title: [],
+      triggerDetails: (_) => se_TriggerDetails(_, context)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartIncidentCommand");
+var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      tags: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_TagResourceCommand");
+var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/tags/{resourceArn}");
+  b.p("resourceArn", () => input.resourceArn, "{resourceArn}", false);
+  const query = (0, import_smithy_client.map)({
+    [_tK]: [
+      (0, import_smithy_client.expectNonNull)(input.tagKeys, `tagKeys`) != null,
+      () => (input[_tK] || []).map((_entry) => _entry)
+    ]
+  });
+  let body;
+  b.m("DELETE").h(headers).q(query).b(body);
+  return b.build();
+}, "se_UntagResourceCommand");
+var se_UpdateDeletionProtectionCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/updateDeletionProtection");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: [],
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      deletionProtected: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateDeletionProtectionCommand");
+var se_UpdateIncidentRecordCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/updateIncidentRecord");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      arn: [],
+      chatChannel: (_) => (0, import_smithy_client._json)(_),
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      impact: [],
+      notificationTargets: (_) => (0, import_smithy_client._json)(_),
+      status: [],
+      summary: [],
+      title: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateIncidentRecordCommand");
+var se_UpdateRelatedItemsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/updateRelatedItems");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      incidentRecordArn: [],
+      relatedItemsUpdate: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateRelatedItemsCommand");
+var se_UpdateReplicationSetCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/updateReplicationSet");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      actions: (_) => (0, import_smithy_client._json)(_),
+      arn: [],
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateReplicationSetCommand");
+var se_UpdateResponsePlanCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/updateResponsePlan");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      actions: (_) => (0, import_smithy_client._json)(_),
+      arn: [],
+      chatChannel: (_) => (0, import_smithy_client._json)(_),
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      displayName: [],
+      engagements: (_) => (0, import_smithy_client._json)(_),
+      incidentTemplateDedupeString: [],
+      incidentTemplateImpact: [],
+      incidentTemplateNotificationTargets: (_) => (0, import_smithy_client._json)(_),
+      incidentTemplateSummary: [],
+      incidentTemplateTags: (_) => (0, import_smithy_client._json)(_),
+      incidentTemplateTitle: [],
+      integrations: (_) => (0, import_smithy_client._json)(_)
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateResponsePlanCommand");
+var se_UpdateTimelineEventCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core2.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/updateTimelineEvent");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      clientToken: [true, (_) => _ ?? (0, import_uuid.v4)()],
+      eventData: [],
+      eventId: [],
+      eventReferences: (_) => (0, import_smithy_client._json)(_),
+      eventTime: (_) => Math.round(_.getTime() / 1e3),
+      eventType: [],
+      incidentRecordArn: []
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_UpdateTimelineEventCommand");
+var de_BatchGetIncidentFindingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_BatchGetIncidentFindingsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    errors: import_smithy_client._json,
+    findings: (_) => de_FindingList(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_BatchGetIncidentFindingsCommand");
+var de_BatchGetIncidentFindingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_BatchGetIncidentFindingsCommandError");
+var de_CreateReplicationSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreateReplicationSetCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateReplicationSetCommand");
+var de_CreateReplicationSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ssmincidents#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ssmincidents#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateReplicationSetCommandError");
+var de_CreateResponsePlanCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreateResponsePlanCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    arn: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateResponsePlanCommand");
+var de_CreateResponsePlanCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ssmincidents#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateResponsePlanCommandError");
+var de_CreateTimelineEventCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CreateTimelineEventCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    eventId: import_smithy_client.expectString,
+    incidentRecordArn: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateTimelineEventCommand");
+var de_CreateTimelineEventCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ssmincidents#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_CreateTimelineEventCommandError");
+var de_DeleteIncidentRecordCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteIncidentRecordCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteIncidentRecordCommand");
+var de_DeleteIncidentRecordCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteIncidentRecordCommandError");
+var de_DeleteReplicationSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteReplicationSetCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteReplicationSetCommand");
+var de_DeleteReplicationSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteReplicationSetCommandError");
+var de_DeleteResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_DeleteResourcePolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteResourcePolicyCommand");
+var de_DeleteResourcePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteResourcePolicyCommandError");
+var de_DeleteResponsePlanCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteResponsePlanCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteResponsePlanCommand");
+var de_DeleteResponsePlanCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteResponsePlanCommandError");
+var de_DeleteTimelineEventCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_DeleteTimelineEventCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteTimelineEventCommand");
+var de_DeleteTimelineEventCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_DeleteTimelineEventCommandError");
+var de_GetIncidentRecordCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetIncidentRecordCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    incidentRecord: (_) => de_IncidentRecord(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetIncidentRecordCommand");
+var de_GetIncidentRecordCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetIncidentRecordCommandError");
+var de_GetReplicationSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetReplicationSetCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    replicationSet: (_) => de_ReplicationSet(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetReplicationSetCommand");
+var de_GetReplicationSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetReplicationSetCommandError");
+var de_GetResourcePoliciesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetResourcePoliciesCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    resourcePolicies: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetResourcePoliciesCommand");
+var de_GetResourcePoliciesCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetResourcePoliciesCommandError");
+var de_GetResponsePlanCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetResponsePlanCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    actions: import_smithy_client._json,
+    arn: import_smithy_client.expectString,
+    chatChannel: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_)),
+    displayName: import_smithy_client.expectString,
+    engagements: import_smithy_client._json,
+    incidentTemplate: import_smithy_client._json,
+    integrations: import_smithy_client._json,
+    name: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetResponsePlanCommand");
+var de_GetResponsePlanCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetResponsePlanCommandError");
+var de_GetTimelineEventCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_GetTimelineEventCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    event: (_) => de_TimelineEvent(_, context)
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_GetTimelineEventCommand");
+var de_GetTimelineEventCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_GetTimelineEventCommandError");
+var de_ListIncidentFindingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListIncidentFindingsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    findings: (_) => de_FindingSummaryList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListIncidentFindingsCommand");
+var de_ListIncidentFindingsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListIncidentFindingsCommandError");
+var de_ListIncidentRecordsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListIncidentRecordsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    incidentRecordSummaries: (_) => de_IncidentRecordSummaryList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListIncidentRecordsCommand");
+var de_ListIncidentRecordsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListIncidentRecordsCommandError");
+var de_ListRelatedItemsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListRelatedItemsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    relatedItems: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListRelatedItemsCommand");
+var de_ListRelatedItemsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListRelatedItemsCommandError");
+var de_ListReplicationSetsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListReplicationSetsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    replicationSetArns: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListReplicationSetsCommand");
+var de_ListReplicationSetsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListReplicationSetsCommandError");
+var de_ListResponsePlansCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListResponsePlansCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    nextToken: import_smithy_client.expectString,
+    responsePlanSummaries: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListResponsePlansCommand");
+var de_ListResponsePlansCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListResponsePlansCommandError");
+var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTagsForResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    tags: import_smithy_client._json
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTagsForResourceCommand");
+var de_ListTagsForResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTagsForResourceCommandError");
+var de_ListTimelineEventsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_ListTimelineEventsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    eventSummaries: (_) => de_EventSummaryList(_, context),
+    nextToken: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListTimelineEventsCommand");
+var de_ListTimelineEventsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_ListTimelineEventsCommandError");
+var de_PutResourcePolicyCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_PutResourcePolicyCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    policyId: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_PutResourcePolicyCommand");
+var de_PutResourcePolicyCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_PutResourcePolicyCommandError");
+var de_StartIncidentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_StartIncidentCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await parseBody(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    incidentRecordArn: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartIncidentCommand");
+var de_StartIncidentCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ssmincidents#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_StartIncidentCommandError");
+var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_TagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_TagResourceCommand");
+var de_TagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ssmincidents#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ServiceQuotaExceededException":
+    case "com.amazonaws.ssmincidents#ServiceQuotaExceededException":
+      throw await de_ServiceQuotaExceededExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_TagResourceCommandError");
+var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_UntagResourceCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UntagResourceCommand");
+var de_UntagResourceCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ssmincidents#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UntagResourceCommandError");
+var de_UpdateDeletionProtectionCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_UpdateDeletionProtectionCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateDeletionProtectionCommand");
+var de_UpdateDeletionProtectionCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateDeletionProtectionCommandError");
+var de_UpdateIncidentRecordCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_UpdateIncidentRecordCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateIncidentRecordCommand");
+var de_UpdateIncidentRecordCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ssmincidents#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateIncidentRecordCommandError");
+var de_UpdateRelatedItemsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_UpdateRelatedItemsCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateRelatedItemsCommand");
+var de_UpdateRelatedItemsCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ssmincidents#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateRelatedItemsCommandError");
+var de_UpdateReplicationSetCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_UpdateReplicationSetCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateReplicationSetCommand");
+var de_UpdateReplicationSetCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ssmincidents#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateReplicationSetCommandError");
+var de_UpdateResponsePlanCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_UpdateResponsePlanCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateResponsePlanCommand");
+var de_UpdateResponsePlanCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ssmincidents#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateResponsePlanCommandError");
+var de_UpdateTimelineEventCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_UpdateTimelineEventCommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_UpdateTimelineEventCommand");
+var de_UpdateTimelineEventCommandError = /* @__PURE__ */ __name(async (output, context) => {
+  const parsedOutput = {
+    ...output,
+    body: await parseErrorBody(output.body, context)
+  };
+  const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
+  switch (errorCode) {
+    case "AccessDeniedException":
+    case "com.amazonaws.ssmincidents#AccessDeniedException":
+      throw await de_AccessDeniedExceptionRes(parsedOutput, context);
+    case "ConflictException":
+    case "com.amazonaws.ssmincidents#ConflictException":
+      throw await de_ConflictExceptionRes(parsedOutput, context);
+    case "InternalServerException":
+    case "com.amazonaws.ssmincidents#InternalServerException":
+      throw await de_InternalServerExceptionRes(parsedOutput, context);
+    case "ResourceNotFoundException":
+    case "com.amazonaws.ssmincidents#ResourceNotFoundException":
+      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
+    case "ThrottlingException":
+    case "com.amazonaws.ssmincidents#ThrottlingException":
+      throw await de_ThrottlingExceptionRes(parsedOutput, context);
+    case "ValidationException":
+    case "com.amazonaws.ssmincidents#ValidationException":
+      throw await de_ValidationExceptionRes(parsedOutput, context);
+    default:
+      const parsedBody = parsedOutput.body;
+      return throwDefaultError({
+        output,
+        parsedBody,
+        errorCode
+      });
+  }
+}, "de_UpdateTimelineEventCommandError");
+var throwDefaultError = (0, import_smithy_client.withBaseException)(SSMIncidentsServiceException);
+var de_AccessDeniedExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new AccessDeniedException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_AccessDeniedExceptionRes");
+var de_ConflictExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    resourceIdentifier: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString,
+    retryAfter: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+  Object.assign(contents, doc);
+  const exception = new ConflictException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ConflictExceptionRes");
+var de_InternalServerExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new InternalServerException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_InternalServerExceptionRes");
+var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    resourceIdentifier: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ResourceNotFoundException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ResourceNotFoundExceptionRes");
+var de_ServiceQuotaExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    quotaCode: import_smithy_client.expectString,
+    resourceIdentifier: import_smithy_client.expectString,
+    resourceType: import_smithy_client.expectString,
+    serviceCode: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ServiceQuotaExceededException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ServiceQuotaExceededExceptionRes");
+var de_ThrottlingExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString,
+    quotaCode: import_smithy_client.expectString,
+    serviceCode: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ThrottlingException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ThrottlingExceptionRes");
+var de_ValidationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
+  const contents = (0, import_smithy_client.map)({});
+  const data = parsedOutput.body;
+  const doc = (0, import_smithy_client.take)(data, {
+    message: import_smithy_client.expectString
+  });
+  Object.assign(contents, doc);
+  const exception = new ValidationException({
+    $metadata: deserializeMetadata(parsedOutput),
+    ...contents
+  });
+  return (0, import_smithy_client.decorateServiceException)(exception, parsedOutput.body);
+}, "de_ValidationExceptionRes");
+var se_Condition = /* @__PURE__ */ __name((input, context) => {
+  return Condition.visit(input, {
+    after: (value) => ({ after: Math.round(value.getTime() / 1e3) }),
+    before: (value) => ({ before: Math.round(value.getTime() / 1e3) }),
+    equals: (value) => ({ equals: (0, import_smithy_client._json)(value) }),
+    _: (name, value) => ({ name: value })
+  });
+}, "se_Condition");
+var se_Filter = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    condition: (_) => se_Condition(_, context),
+    key: []
+  });
+}, "se_Filter");
+var se_FilterList = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_Filter(entry, context);
+  });
+}, "se_FilterList");
+var se_TriggerDetails = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    rawData: [],
+    source: [],
+    timestamp: (_) => Math.round(_.getTime() / 1e3),
+    triggerArn: []
+  });
+}, "se_TriggerDetails");
+var de_CloudFormationStackUpdate = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    stackArn: import_smithy_client.expectString,
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_CloudFormationStackUpdate");
+var de_CodeDeployDeployment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    deploymentGroupArn: import_smithy_client.expectString,
+    deploymentId: import_smithy_client.expectString,
+    endTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    startTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_CodeDeployDeployment");
+var de_EventSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    eventId: import_smithy_client.expectString,
+    eventReferences: import_smithy_client._json,
+    eventTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    eventType: import_smithy_client.expectString,
+    eventUpdatedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    incidentRecordArn: import_smithy_client.expectString
+  });
+}, "de_EventSummary");
+var de_EventSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_EventSummary(entry, context);
+  });
+  return retVal;
+}, "de_EventSummaryList");
+var de_Finding = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    creationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    details: (_) => de_FindingDetails((0, import_core.awsExpectUnion)(_), context),
+    id: import_smithy_client.expectString,
+    lastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_Finding");
+var de_FindingDetails = /* @__PURE__ */ __name((output, context) => {
+  if (output.cloudFormationStackUpdate != null) {
+    return {
+      cloudFormationStackUpdate: de_CloudFormationStackUpdate(output.cloudFormationStackUpdate, context)
+    };
+  }
+  if (output.codeDeployDeployment != null) {
+    return {
+      codeDeployDeployment: de_CodeDeployDeployment(output.codeDeployDeployment, context)
+    };
+  }
+  return { $unknown: Object.entries(output)[0] };
+}, "de_FindingDetails");
+var de_FindingList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_Finding(entry, context);
+  });
+  return retVal;
+}, "de_FindingList");
+var de_FindingSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    id: import_smithy_client.expectString,
+    lastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_FindingSummary");
+var de_FindingSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_FindingSummary(entry, context);
+  });
+  return retVal;
+}, "de_FindingSummaryList");
+var de_IncidentRecord = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    automationExecutions: import_smithy_client._json,
+    chatChannel: (_) => (0, import_smithy_client._json)((0, import_core.awsExpectUnion)(_)),
+    creationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    dedupeString: import_smithy_client.expectString,
+    impact: import_smithy_client.expectInt32,
+    incidentRecordSource: import_smithy_client._json,
+    lastModifiedBy: import_smithy_client.expectString,
+    lastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    notificationTargets: import_smithy_client._json,
+    resolvedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    status: import_smithy_client.expectString,
+    summary: import_smithy_client.expectString,
+    title: import_smithy_client.expectString
+  });
+}, "de_IncidentRecord");
+var de_IncidentRecordSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    creationTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    impact: import_smithy_client.expectInt32,
+    incidentRecordSource: import_smithy_client._json,
+    resolvedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    status: import_smithy_client.expectString,
+    title: import_smithy_client.expectString
+  });
+}, "de_IncidentRecordSummary");
+var de_IncidentRecordSummaryList = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_IncidentRecordSummary(entry, context);
+  });
+  return retVal;
+}, "de_IncidentRecordSummaryList");
+var de_RegionInfo = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    sseKmsKeyId: import_smithy_client.expectString,
+    status: import_smithy_client.expectString,
+    statusMessage: import_smithy_client.expectString,
+    statusUpdateDateTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_)))
+  });
+}, "de_RegionInfo");
+var de_RegionInfoMap = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_RegionInfo(value, context);
+    return acc;
+  }, {});
+}, "de_RegionInfoMap");
+var de_ReplicationSet = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    arn: import_smithy_client.expectString,
+    createdBy: import_smithy_client.expectString,
+    createdTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    deletionProtected: import_smithy_client.expectBoolean,
+    lastModifiedBy: import_smithy_client.expectString,
+    lastModifiedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    regionMap: (_) => de_RegionInfoMap(_, context),
+    status: import_smithy_client.expectString
+  });
+}, "de_ReplicationSet");
+var de_TimelineEvent = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    eventData: import_smithy_client.expectString,
+    eventId: import_smithy_client.expectString,
+    eventReferences: import_smithy_client._json,
+    eventTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    eventType: import_smithy_client.expectString,
+    eventUpdatedTime: (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseEpochTimestamp)((0, import_smithy_client.expectNumber)(_))),
+    incidentRecordArn: import_smithy_client.expectString
+  });
+}, "de_TimelineEvent");
+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 _a = "arn";
+var _eI = "eventId";
+var _iRA = "incidentRecordArn";
+var _rA = "resourceArn";
+var _tK = "tagKeys";
+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/BatchGetIncidentFindingsCommand.ts
+var _BatchGetIncidentFindingsCommand = class _BatchGetIncidentFindingsCommand 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("SSMIncidents", "BatchGetIncidentFindings", {}).n("SSMIncidentsClient", "BatchGetIncidentFindingsCommand").f(void 0, void 0).ser(se_BatchGetIncidentFindingsCommand).de(de_BatchGetIncidentFindingsCommand).build() {
+};
+__name(_BatchGetIncidentFindingsCommand, "BatchGetIncidentFindingsCommand");
+var BatchGetIncidentFindingsCommand = _BatchGetIncidentFindingsCommand;
+
+// src/commands/CreateReplicationSetCommand.ts
+
+
+
+
+var _CreateReplicationSetCommand = class _CreateReplicationSetCommand 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("SSMIncidents", "CreateReplicationSet", {}).n("SSMIncidentsClient", "CreateReplicationSetCommand").f(void 0, void 0).ser(se_CreateReplicationSetCommand).de(de_CreateReplicationSetCommand).build() {
+};
+__name(_CreateReplicationSetCommand, "CreateReplicationSetCommand");
+var CreateReplicationSetCommand = _CreateReplicationSetCommand;
+
+// src/commands/CreateResponsePlanCommand.ts
+
+
+
+
+var _CreateResponsePlanCommand = class _CreateResponsePlanCommand 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("SSMIncidents", "CreateResponsePlan", {}).n("SSMIncidentsClient", "CreateResponsePlanCommand").f(void 0, void 0).ser(se_CreateResponsePlanCommand).de(de_CreateResponsePlanCommand).build() {
+};
+__name(_CreateResponsePlanCommand, "CreateResponsePlanCommand");
+var CreateResponsePlanCommand = _CreateResponsePlanCommand;
+
+// src/commands/CreateTimelineEventCommand.ts
+
+
+
+
+var _CreateTimelineEventCommand = class _CreateTimelineEventCommand 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("SSMIncidents", "CreateTimelineEvent", {}).n("SSMIncidentsClient", "CreateTimelineEventCommand").f(void 0, void 0).ser(se_CreateTimelineEventCommand).de(de_CreateTimelineEventCommand).build() {
+};
+__name(_CreateTimelineEventCommand, "CreateTimelineEventCommand");
+var CreateTimelineEventCommand = _CreateTimelineEventCommand;
+
+// src/commands/DeleteIncidentRecordCommand.ts
+
+
+
+
+var _DeleteIncidentRecordCommand = class _DeleteIncidentRecordCommand 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("SSMIncidents", "DeleteIncidentRecord", {}).n("SSMIncidentsClient", "DeleteIncidentRecordCommand").f(void 0, void 0).ser(se_DeleteIncidentRecordCommand).de(de_DeleteIncidentRecordCommand).build() {
+};
+__name(_DeleteIncidentRecordCommand, "DeleteIncidentRecordCommand");
+var DeleteIncidentRecordCommand = _DeleteIncidentRecordCommand;
+
+// src/commands/DeleteReplicationSetCommand.ts
+
+
+
+
+var _DeleteReplicationSetCommand = class _DeleteReplicationSetCommand 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("SSMIncidents", "DeleteReplicationSet", {}).n("SSMIncidentsClient", "DeleteReplicationSetCommand").f(void 0, void 0).ser(se_DeleteReplicationSetCommand).de(de_DeleteReplicationSetCommand).build() {
+};
+__name(_DeleteReplicationSetCommand, "DeleteReplicationSetCommand");
+var DeleteReplicationSetCommand = _DeleteReplicationSetCommand;
+
+// src/commands/DeleteResourcePolicyCommand.ts
+
+
+
+
+var _DeleteResourcePolicyCommand = class _DeleteResourcePolicyCommand 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("SSMIncidents", "DeleteResourcePolicy", {}).n("SSMIncidentsClient", "DeleteResourcePolicyCommand").f(void 0, void 0).ser(se_DeleteResourcePolicyCommand).de(de_DeleteResourcePolicyCommand).build() {
+};
+__name(_DeleteResourcePolicyCommand, "DeleteResourcePolicyCommand");
+var DeleteResourcePolicyCommand = _DeleteResourcePolicyCommand;
+
+// src/commands/DeleteResponsePlanCommand.ts
+
+
+
+
+var _DeleteResponsePlanCommand = class _DeleteResponsePlanCommand 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("SSMIncidents", "DeleteResponsePlan", {}).n("SSMIncidentsClient", "DeleteResponsePlanCommand").f(void 0, void 0).ser(se_DeleteResponsePlanCommand).de(de_DeleteResponsePlanCommand).build() {
+};
+__name(_DeleteResponsePlanCommand, "DeleteResponsePlanCommand");
+var DeleteResponsePlanCommand = _DeleteResponsePlanCommand;
+
+// src/commands/DeleteTimelineEventCommand.ts
+
+
+
+
+var _DeleteTimelineEventCommand = class _DeleteTimelineEventCommand 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("SSMIncidents", "DeleteTimelineEvent", {}).n("SSMIncidentsClient", "DeleteTimelineEventCommand").f(void 0, void 0).ser(se_DeleteTimelineEventCommand).de(de_DeleteTimelineEventCommand).build() {
+};
+__name(_DeleteTimelineEventCommand, "DeleteTimelineEventCommand");
+var DeleteTimelineEventCommand = _DeleteTimelineEventCommand;
+
+// src/commands/GetIncidentRecordCommand.ts
+
+
+
+
+var _GetIncidentRecordCommand = class _GetIncidentRecordCommand 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("SSMIncidents", "GetIncidentRecord", {}).n("SSMIncidentsClient", "GetIncidentRecordCommand").f(void 0, void 0).ser(se_GetIncidentRecordCommand).de(de_GetIncidentRecordCommand).build() {
+};
+__name(_GetIncidentRecordCommand, "GetIncidentRecordCommand");
+var GetIncidentRecordCommand = _GetIncidentRecordCommand;
+
+// src/commands/GetReplicationSetCommand.ts
+
+
+
+
+var _GetReplicationSetCommand = class _GetReplicationSetCommand 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("SSMIncidents", "GetReplicationSet", {}).n("SSMIncidentsClient", "GetReplicationSetCommand").f(void 0, void 0).ser(se_GetReplicationSetCommand).de(de_GetReplicationSetCommand).build() {
+};
+__name(_GetReplicationSetCommand, "GetReplicationSetCommand");
+var GetReplicationSetCommand = _GetReplicationSetCommand;
+
+// src/commands/GetResourcePoliciesCommand.ts
+
+
+
+
+var _GetResourcePoliciesCommand = class _GetResourcePoliciesCommand 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("SSMIncidents", "GetResourcePolicies", {}).n("SSMIncidentsClient", "GetResourcePoliciesCommand").f(void 0, void 0).ser(se_GetResourcePoliciesCommand).de(de_GetResourcePoliciesCommand).build() {
+};
+__name(_GetResourcePoliciesCommand, "GetResourcePoliciesCommand");
+var GetResourcePoliciesCommand = _GetResourcePoliciesCommand;
+
+// src/commands/GetResponsePlanCommand.ts
+
+
+
+
+var _GetResponsePlanCommand = class _GetResponsePlanCommand 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("SSMIncidents", "GetResponsePlan", {}).n("SSMIncidentsClient", "GetResponsePlanCommand").f(void 0, void 0).ser(se_GetResponsePlanCommand).de(de_GetResponsePlanCommand).build() {
+};
+__name(_GetResponsePlanCommand, "GetResponsePlanCommand");
+var GetResponsePlanCommand = _GetResponsePlanCommand;
+
+// src/commands/GetTimelineEventCommand.ts
+
+
+
+
+var _GetTimelineEventCommand = class _GetTimelineEventCommand 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("SSMIncidents", "GetTimelineEvent", {}).n("SSMIncidentsClient", "GetTimelineEventCommand").f(void 0, void 0).ser(se_GetTimelineEventCommand).de(de_GetTimelineEventCommand).build() {
+};
+__name(_GetTimelineEventCommand, "GetTimelineEventCommand");
+var GetTimelineEventCommand = _GetTimelineEventCommand;
+
+// src/commands/ListIncidentFindingsCommand.ts
+
+
+
+
+var _ListIncidentFindingsCommand = class _ListIncidentFindingsCommand 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("SSMIncidents", "ListIncidentFindings", {}).n("SSMIncidentsClient", "ListIncidentFindingsCommand").f(void 0, void 0).ser(se_ListIncidentFindingsCommand).de(de_ListIncidentFindingsCommand).build() {
+};
+__name(_ListIncidentFindingsCommand, "ListIncidentFindingsCommand");
+var ListIncidentFindingsCommand = _ListIncidentFindingsCommand;
+
+// src/commands/ListIncidentRecordsCommand.ts
+
+
+
+
+var _ListIncidentRecordsCommand = class _ListIncidentRecordsCommand 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("SSMIncidents", "ListIncidentRecords", {}).n("SSMIncidentsClient", "ListIncidentRecordsCommand").f(void 0, void 0).ser(se_ListIncidentRecordsCommand).de(de_ListIncidentRecordsCommand).build() {
+};
+__name(_ListIncidentRecordsCommand, "ListIncidentRecordsCommand");
+var ListIncidentRecordsCommand = _ListIncidentRecordsCommand;
+
+// src/commands/ListRelatedItemsCommand.ts
+
+
+
+
+var _ListRelatedItemsCommand = class _ListRelatedItemsCommand 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("SSMIncidents", "ListRelatedItems", {}).n("SSMIncidentsClient", "ListRelatedItemsCommand").f(void 0, void 0).ser(se_ListRelatedItemsCommand).de(de_ListRelatedItemsCommand).build() {
+};
+__name(_ListRelatedItemsCommand, "ListRelatedItemsCommand");
+var ListRelatedItemsCommand = _ListRelatedItemsCommand;
+
+// src/commands/ListReplicationSetsCommand.ts
+
+
+
+
+var _ListReplicationSetsCommand = class _ListReplicationSetsCommand 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("SSMIncidents", "ListReplicationSets", {}).n("SSMIncidentsClient", "ListReplicationSetsCommand").f(void 0, void 0).ser(se_ListReplicationSetsCommand).de(de_ListReplicationSetsCommand).build() {
+};
+__name(_ListReplicationSetsCommand, "ListReplicationSetsCommand");
+var ListReplicationSetsCommand = _ListReplicationSetsCommand;
+
+// src/commands/ListResponsePlansCommand.ts
+
+
+
+
+var _ListResponsePlansCommand = class _ListResponsePlansCommand 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("SSMIncidents", "ListResponsePlans", {}).n("SSMIncidentsClient", "ListResponsePlansCommand").f(void 0, void 0).ser(se_ListResponsePlansCommand).de(de_ListResponsePlansCommand).build() {
+};
+__name(_ListResponsePlansCommand, "ListResponsePlansCommand");
+var ListResponsePlansCommand = _ListResponsePlansCommand;
+
+// src/commands/ListTagsForResourceCommand.ts
+
+
+
+
+var _ListTagsForResourceCommand = class _ListTagsForResourceCommand 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("SSMIncidents", "ListTagsForResource", {}).n("SSMIncidentsClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
+};
+__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
+var ListTagsForResourceCommand = _ListTagsForResourceCommand;
+
+// src/commands/ListTimelineEventsCommand.ts
+
+
+
+
+var _ListTimelineEventsCommand = class _ListTimelineEventsCommand 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("SSMIncidents", "ListTimelineEvents", {}).n("SSMIncidentsClient", "ListTimelineEventsCommand").f(void 0, void 0).ser(se_ListTimelineEventsCommand).de(de_ListTimelineEventsCommand).build() {
+};
+__name(_ListTimelineEventsCommand, "ListTimelineEventsCommand");
+var ListTimelineEventsCommand = _ListTimelineEventsCommand;
+
+// src/commands/PutResourcePolicyCommand.ts
+
+
+
+
+var _PutResourcePolicyCommand = class _PutResourcePolicyCommand 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("SSMIncidents", "PutResourcePolicy", {}).n("SSMIncidentsClient", "PutResourcePolicyCommand").f(void 0, void 0).ser(se_PutResourcePolicyCommand).de(de_PutResourcePolicyCommand).build() {
+};
+__name(_PutResourcePolicyCommand, "PutResourcePolicyCommand");
+var PutResourcePolicyCommand = _PutResourcePolicyCommand;
+
+// src/commands/StartIncidentCommand.ts
+
+
+
+
+var _StartIncidentCommand = class _StartIncidentCommand 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("SSMIncidents", "StartIncident", {}).n("SSMIncidentsClient", "StartIncidentCommand").f(void 0, void 0).ser(se_StartIncidentCommand).de(de_StartIncidentCommand).build() {
+};
+__name(_StartIncidentCommand, "StartIncidentCommand");
+var StartIncidentCommand = _StartIncidentCommand;
+
+// src/commands/TagResourceCommand.ts
+
+
+
+
+var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SSMIncidents", "TagResource", {}).n("SSMIncidentsClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
+};
+__name(_TagResourceCommand, "TagResourceCommand");
+var TagResourceCommand = _TagResourceCommand;
+
+// src/commands/UntagResourceCommand.ts
+
+
+
+
+var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
+  ...commonParams
+}).m(function(Command, cs, config, o) {
+  return [
+    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
+    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
+  ];
+}).s("SSMIncidents", "UntagResource", {}).n("SSMIncidentsClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
+};
+__name(_UntagResourceCommand, "UntagResourceCommand");
+var UntagResourceCommand = _UntagResourceCommand;
+
+// src/commands/UpdateDeletionProtectionCommand.ts
+
+
+
+
+var _UpdateDeletionProtectionCommand = class _UpdateDeletionProtectionCommand 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("SSMIncidents", "UpdateDeletionProtection", {}).n("SSMIncidentsClient", "UpdateDeletionProtectionCommand").f(void 0, void 0).ser(se_UpdateDeletionProtectionCommand).de(de_UpdateDeletionProtectionCommand).build() {
+};
+__name(_UpdateDeletionProtectionCommand, "UpdateDeletionProtectionCommand");
+var UpdateDeletionProtectionCommand = _UpdateDeletionProtectionCommand;
+
+// src/commands/UpdateIncidentRecordCommand.ts
+
+
+
+
+var _UpdateIncidentRecordCommand = class _UpdateIncidentRecordCommand 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("SSMIncidents", "UpdateIncidentRecord", {}).n("SSMIncidentsClient", "UpdateIncidentRecordCommand").f(void 0, void 0).ser(se_UpdateIncidentRecordCommand).de(de_UpdateIncidentRecordCommand).build() {
+};
+__name(_UpdateIncidentRecordCommand, "UpdateIncidentRecordCommand");
+var UpdateIncidentRecordCommand = _UpdateIncidentRecordCommand;
+
+// src/commands/UpdateRelatedItemsCommand.ts
+
+
+
+
+var _UpdateRelatedItemsCommand = class _UpdateRelatedItemsCommand 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("SSMIncidents", "UpdateRelatedItems", {}).n("SSMIncidentsClient", "UpdateRelatedItemsCommand").f(void 0, void 0).ser(se_UpdateRelatedItemsCommand).de(de_UpdateRelatedItemsCommand).build() {
+};
+__name(_UpdateRelatedItemsCommand, "UpdateRelatedItemsCommand");
+var UpdateRelatedItemsCommand = _UpdateRelatedItemsCommand;
+
+// src/commands/UpdateReplicationSetCommand.ts
+
+
+
+
+var _UpdateReplicationSetCommand = class _UpdateReplicationSetCommand 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("SSMIncidents", "UpdateReplicationSet", {}).n("SSMIncidentsClient", "UpdateReplicationSetCommand").f(void 0, void 0).ser(se_UpdateReplicationSetCommand).de(de_UpdateReplicationSetCommand).build() {
+};
+__name(_UpdateReplicationSetCommand, "UpdateReplicationSetCommand");
+var UpdateReplicationSetCommand = _UpdateReplicationSetCommand;
+
+// src/commands/UpdateResponsePlanCommand.ts
+
+
+
+
+var _UpdateResponsePlanCommand = class _UpdateResponsePlanCommand 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("SSMIncidents", "UpdateResponsePlan", {}).n("SSMIncidentsClient", "UpdateResponsePlanCommand").f(void 0, void 0).ser(se_UpdateResponsePlanCommand).de(de_UpdateResponsePlanCommand).build() {
+};
+__name(_UpdateResponsePlanCommand, "UpdateResponsePlanCommand");
+var UpdateResponsePlanCommand = _UpdateResponsePlanCommand;
+
+// src/commands/UpdateTimelineEventCommand.ts
+
+
+
+
+var _UpdateTimelineEventCommand = class _UpdateTimelineEventCommand 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("SSMIncidents", "UpdateTimelineEvent", {}).n("SSMIncidentsClient", "UpdateTimelineEventCommand").f(void 0, void 0).ser(se_UpdateTimelineEventCommand).de(de_UpdateTimelineEventCommand).build() {
+};
+__name(_UpdateTimelineEventCommand, "UpdateTimelineEventCommand");
+var UpdateTimelineEventCommand = _UpdateTimelineEventCommand;
+
+// src/SSMIncidents.ts
+var commands = {
+  BatchGetIncidentFindingsCommand,
+  CreateReplicationSetCommand,
+  CreateResponsePlanCommand,
+  CreateTimelineEventCommand,
+  DeleteIncidentRecordCommand,
+  DeleteReplicationSetCommand,
+  DeleteResourcePolicyCommand,
+  DeleteResponsePlanCommand,
+  DeleteTimelineEventCommand,
+  GetIncidentRecordCommand,
+  GetReplicationSetCommand,
+  GetResourcePoliciesCommand,
+  GetResponsePlanCommand,
+  GetTimelineEventCommand,
+  ListIncidentFindingsCommand,
+  ListIncidentRecordsCommand,
+  ListRelatedItemsCommand,
+  ListReplicationSetsCommand,
+  ListResponsePlansCommand,
+  ListTagsForResourceCommand,
+  ListTimelineEventsCommand,
+  PutResourcePolicyCommand,
+  StartIncidentCommand,
+  TagResourceCommand,
+  UntagResourceCommand,
+  UpdateDeletionProtectionCommand,
+  UpdateIncidentRecordCommand,
+  UpdateRelatedItemsCommand,
+  UpdateReplicationSetCommand,
+  UpdateResponsePlanCommand,
+  UpdateTimelineEventCommand
+};
+var _SSMIncidents = class _SSMIncidents extends SSMIncidentsClient {
+};
+__name(_SSMIncidents, "SSMIncidents");
+var SSMIncidents = _SSMIncidents;
+(0, import_smithy_client.createAggregatedClient)(commands, SSMIncidents);
+
+// src/pagination/GetResourcePoliciesPaginator.ts
+var import_core3 = require("@smithy/core");
+var paginateGetResourcePolicies = (0, import_core3.createPaginator)(SSMIncidentsClient, GetResourcePoliciesCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListIncidentFindingsPaginator.ts
+var import_core4 = require("@smithy/core");
+var paginateListIncidentFindings = (0, import_core4.createPaginator)(SSMIncidentsClient, ListIncidentFindingsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListIncidentRecordsPaginator.ts
+var import_core5 = require("@smithy/core");
+var paginateListIncidentRecords = (0, import_core5.createPaginator)(SSMIncidentsClient, ListIncidentRecordsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListRelatedItemsPaginator.ts
+var import_core6 = require("@smithy/core");
+var paginateListRelatedItems = (0, import_core6.createPaginator)(SSMIncidentsClient, ListRelatedItemsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListReplicationSetsPaginator.ts
+var import_core7 = require("@smithy/core");
+var paginateListReplicationSets = (0, import_core7.createPaginator)(SSMIncidentsClient, ListReplicationSetsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListResponsePlansPaginator.ts
+var import_core8 = require("@smithy/core");
+var paginateListResponsePlans = (0, import_core8.createPaginator)(SSMIncidentsClient, ListResponsePlansCommand, "nextToken", "nextToken", "maxResults");
+
+// src/pagination/ListTimelineEventsPaginator.ts
+var import_core9 = require("@smithy/core");
+var paginateListTimelineEvents = (0, import_core9.createPaginator)(SSMIncidentsClient, ListTimelineEventsCommand, "nextToken", "nextToken", "maxResults");
+
+// src/waiters/waitForWaitForReplicationSetActive.ts
+var import_util_waiter = require("@smithy/util-waiter");
+var checkState = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetReplicationSetCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.replicationSet.status;
+      }, "returnComparator");
+      if (returnComparator() === "ACTIVE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.replicationSet.status;
+      }, "returnComparator");
+      if (returnComparator() === "CREATING") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.replicationSet.status;
+      }, "returnComparator");
+      if (returnComparator() === "UPDATING") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.replicationSet.status;
+      }, "returnComparator");
+      if (returnComparator() === "FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForWaitForReplicationSetActive = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 30 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+}, "waitForWaitForReplicationSetActive");
+var waitUntilWaitForReplicationSetActive = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 30 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilWaitForReplicationSetActive");
+
+// src/waiters/waitForWaitForReplicationSetDeleted.ts
+
+var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetReplicationSetCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.replicationSet.status;
+      }, "returnComparator");
+      if (returnComparator() === "DELETING") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.replicationSet.status;
+      }, "returnComparator");
+      if (returnComparator() === "FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+    if (exception.name && exception.name == "ResourceNotFoundException") {
+      return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+    }
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForWaitForReplicationSetDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 30 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+}, "waitForWaitForReplicationSetDeleted");
+var waitUntilWaitForReplicationSetDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 30, maxDelay: 30 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilWaitForReplicationSetDeleted");
+
+// 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 = {
+  AccessDeniedException,
+  Action,
+  AttributeValueList,
+  AutomationExecution,
+  BatchGetIncidentFindingsCommand,
+  ChatChannel,
+  Condition,
+  ConflictException,
+  CreateReplicationSetCommand,
+  CreateResponsePlanCommand,
+  CreateTimelineEventCommand,
+  DeleteIncidentRecordCommand,
+  DeleteReplicationSetCommand,
+  DeleteResourcePolicyCommand,
+  DeleteResponsePlanCommand,
+  DeleteTimelineEventCommand,
+  DynamicSsmParameterValue,
+  EventReference,
+  FindingDetails,
+  GetIncidentRecordCommand,
+  GetReplicationSetCommand,
+  GetResourcePoliciesCommand,
+  GetResponsePlanCommand,
+  GetTimelineEventCommand,
+  IncidentRecordStatus,
+  Integration,
+  InternalServerException,
+  ItemType,
+  ItemValue,
+  ListIncidentFindingsCommand,
+  ListIncidentRecordsCommand,
+  ListRelatedItemsCommand,
+  ListReplicationSetsCommand,
+  ListResponsePlansCommand,
+  ListTagsForResourceCommand,
+  ListTimelineEventsCommand,
+  NotificationTargetItem,
+  PutResourcePolicyCommand,
+  RegionStatus,
+  RelatedItemsUpdate,
+  ReplicationSetStatus,
+  ResourceNotFoundException,
+  ResourceType,
+  SSMIncidents,
+  SSMIncidentsClient,
+  SSMIncidentsServiceException,
+  ServiceCode,
+  ServiceQuotaExceededException,
+  SortOrder,
+  SsmTargetAccount,
+  StartIncidentCommand,
+  TagResourceCommand,
+  ThrottlingException,
+  TimelineEventSort,
+  UntagResourceCommand,
+  UpdateDeletionProtectionCommand,
+  UpdateIncidentRecordCommand,
+  UpdateRelatedItemsCommand,
+  UpdateReplicationSetAction,
+  UpdateReplicationSetCommand,
+  UpdateResponsePlanCommand,
+  UpdateTimelineEventCommand,
+  ValidationException,
+  VariableType,
+  __Client,
+  paginateGetResourcePolicies,
+  paginateListIncidentFindings,
+  paginateListIncidentRecords,
+  paginateListRelatedItems,
+  paginateListReplicationSets,
+  paginateListResponsePlans,
+  paginateListTimelineEvents,
+  waitForWaitForReplicationSetActive,
+  waitForWaitForReplicationSetDeleted,
+  waitUntilWaitForReplicationSetActive,
+  waitUntilWaitForReplicationSetDeleted
+});
+