@aws-sdk/client-medialive 3.549.0 → 3.554.0

package/dist-cjs/index.js

@@ -68,27 +68,41 @@ __export(src_exports, {
   ChannelPipelineIdToRestart: () => ChannelPipelineIdToRestart,
   ChannelState: () => ChannelState,
   ClaimDeviceCommand: () => ClaimDeviceCommand,
+  CloudWatchAlarmTemplateComparisonOperator: () => CloudWatchAlarmTemplateComparisonOperator,
+  CloudWatchAlarmTemplateStatistic: () => CloudWatchAlarmTemplateStatistic,
+  CloudWatchAlarmTemplateTargetResourceType: () => CloudWatchAlarmTemplateTargetResourceType,
+  CloudWatchAlarmTemplateTreatMissingData: () => CloudWatchAlarmTemplateTreatMissingData,
   CmafIngestSegmentLengthUnits: () => CmafIngestSegmentLengthUnits,
   CmafNielsenId3Behavior: () => CmafNielsenId3Behavior,
   ColorSpace: () => ColorSpace,
   ConflictException: () => ConflictException,
   ContentType: () => ContentType,
   CreateChannelCommand: () => CreateChannelCommand,
+  CreateCloudWatchAlarmTemplateCommand: () => CreateCloudWatchAlarmTemplateCommand,
+  CreateCloudWatchAlarmTemplateGroupCommand: () => CreateCloudWatchAlarmTemplateGroupCommand,
+  CreateEventBridgeRuleTemplateCommand: () => CreateEventBridgeRuleTemplateCommand,
+  CreateEventBridgeRuleTemplateGroupCommand: () => CreateEventBridgeRuleTemplateGroupCommand,
   CreateInputCommand: () => CreateInputCommand,
   CreateInputSecurityGroupCommand: () => CreateInputSecurityGroupCommand,
   CreateMultiplexCommand: () => CreateMultiplexCommand,
   CreateMultiplexProgramCommand: () => CreateMultiplexProgramCommand,
   CreatePartnerInputCommand: () => CreatePartnerInputCommand,
+  CreateSignalMapCommand: () => CreateSignalMapCommand,
   CreateTagsCommand: () => CreateTagsCommand,
   DashRoleAudio: () => DashRoleAudio,
   DashRoleCaption: () => DashRoleCaption,
   DeleteChannelCommand: () => DeleteChannelCommand,
+  DeleteCloudWatchAlarmTemplateCommand: () => DeleteCloudWatchAlarmTemplateCommand,
+  DeleteCloudWatchAlarmTemplateGroupCommand: () => DeleteCloudWatchAlarmTemplateGroupCommand,
+  DeleteEventBridgeRuleTemplateCommand: () => DeleteEventBridgeRuleTemplateCommand,
+  DeleteEventBridgeRuleTemplateGroupCommand: () => DeleteEventBridgeRuleTemplateGroupCommand,
   DeleteInputCommand: () => DeleteInputCommand,
   DeleteInputSecurityGroupCommand: () => DeleteInputSecurityGroupCommand,
   DeleteMultiplexCommand: () => DeleteMultiplexCommand,
   DeleteMultiplexProgramCommand: () => DeleteMultiplexProgramCommand,
   DeleteReservationCommand: () => DeleteReservationCommand,
   DeleteScheduleCommand: () => DeleteScheduleCommand,
+  DeleteSignalMapCommand: () => DeleteSignalMapCommand,
   DeleteTagsCommand: () => DeleteTagsCommand,
   DescribeAccountConfigurationCommand: () => DescribeAccountConfigurationCommand,
   DescribeChannelCommand: () => DescribeChannelCommand,
@@ -136,6 +150,7 @@ __export(src_exports, {
   EbuTtDFillLineGapControl: () => EbuTtDFillLineGapControl,
   EmbeddedConvert608To708: () => EmbeddedConvert608To708,
   EmbeddedScte20Detection: () => EmbeddedScte20Detection,
+  EventBridgeRuleTemplateEventType: () => EventBridgeRuleTemplateEventType,
   FeatureActivationsInputPrepareScheduleActions: () => FeatureActivationsInputPrepareScheduleActions,
   FeatureActivationsOutputStaticImageOverlayScheduleActions: () => FeatureActivationsOutputStaticImageOverlayScheduleActions,
   FecOutputIncludeFec: () => FecOutputIncludeFec,
@@ -146,6 +161,11 @@ __export(src_exports, {
   ForbiddenException: () => ForbiddenException,
   FrameCaptureIntervalUnit: () => FrameCaptureIntervalUnit,
   GatewayTimeoutException: () => GatewayTimeoutException,
+  GetCloudWatchAlarmTemplateCommand: () => GetCloudWatchAlarmTemplateCommand,
+  GetCloudWatchAlarmTemplateGroupCommand: () => GetCloudWatchAlarmTemplateGroupCommand,
+  GetEventBridgeRuleTemplateCommand: () => GetEventBridgeRuleTemplateCommand,
+  GetEventBridgeRuleTemplateGroupCommand: () => GetEventBridgeRuleTemplateGroupCommand,
+  GetSignalMapCommand: () => GetSignalMapCommand,
   GlobalConfigurationInputEndAction: () => GlobalConfigurationInputEndAction,
   GlobalConfigurationLowFramerateInputs: () => GlobalConfigurationLowFramerateInputs,
   GlobalConfigurationOutputLockingMode: () => GlobalConfigurationOutputLockingMode,
@@ -251,6 +271,10 @@ __export(src_exports, {
   InternalServerErrorException: () => InternalServerErrorException,
   LastFrameClippingBehavior: () => LastFrameClippingBehavior,
   ListChannelsCommand: () => ListChannelsCommand,
+  ListCloudWatchAlarmTemplateGroupsCommand: () => ListCloudWatchAlarmTemplateGroupsCommand,
+  ListCloudWatchAlarmTemplatesCommand: () => ListCloudWatchAlarmTemplatesCommand,
+  ListEventBridgeRuleTemplateGroupsCommand: () => ListEventBridgeRuleTemplateGroupsCommand,
+  ListEventBridgeRuleTemplatesCommand: () => ListEventBridgeRuleTemplatesCommand,
   ListInputDeviceTransfersCommand: () => ListInputDeviceTransfersCommand,
   ListInputDevicesCommand: () => ListInputDevicesCommand,
   ListInputSecurityGroupsCommand: () => ListInputSecurityGroupsCommand,
@@ -259,6 +283,7 @@ __export(src_exports, {
   ListMultiplexesCommand: () => ListMultiplexesCommand,
   ListOfferingsCommand: () => ListOfferingsCommand,
   ListReservationsCommand: () => ListReservationsCommand,
+  ListSignalMapsCommand: () => ListSignalMapsCommand,
   ListTagsForResourceCommand: () => ListTagsForResourceCommand,
   LogLevel: () => LogLevel,
   M2tsAbsentInputAudioBehavior: () => M2tsAbsentInputAudioBehavior,
@@ -343,6 +368,8 @@ __export(src_exports, {
   Scte35SpliceInsertWebDeliveryAllowedBehavior: () => Scte35SpliceInsertWebDeliveryAllowedBehavior,
   Scte35Type: () => Scte35Type,
   Scte35WebDeliveryAllowedFlag: () => Scte35WebDeliveryAllowedFlag,
+  SignalMapMonitorDeploymentStatus: () => SignalMapMonitorDeploymentStatus,
+  SignalMapStatus: () => SignalMapStatus,
   SmoothGroupAudioOnlyTimecodeControl: () => SmoothGroupAudioOnlyTimecodeControl,
   SmoothGroupCertificateMode: () => SmoothGroupCertificateMode,
   SmoothGroupEventIdMode: () => SmoothGroupEventIdMode,
@@ -353,9 +380,12 @@ __export(src_exports, {
   SmoothGroupTimestampOffsetMode: () => SmoothGroupTimestampOffsetMode,
   Smpte2038DataPreference: () => Smpte2038DataPreference,
   StartChannelCommand: () => StartChannelCommand,
+  StartDeleteMonitorDeploymentCommand: () => StartDeleteMonitorDeploymentCommand,
   StartInputDeviceCommand: () => StartInputDeviceCommand,
   StartInputDeviceMaintenanceWindowCommand: () => StartInputDeviceMaintenanceWindowCommand,
+  StartMonitorDeploymentCommand: () => StartMonitorDeploymentCommand,
   StartMultiplexCommand: () => StartMultiplexCommand,
+  StartUpdateSignalMapCommand: () => StartUpdateSignalMapCommand,
   StopChannelCommand: () => StopChannelCommand,
   StopInputDeviceCommand: () => StopInputDeviceCommand,
   StopMultiplexCommand: () => StopMultiplexCommand,
@@ -374,6 +404,10 @@ __export(src_exports, {
   UpdateAccountConfigurationCommand: () => UpdateAccountConfigurationCommand,
   UpdateChannelClassCommand: () => UpdateChannelClassCommand,
   UpdateChannelCommand: () => UpdateChannelCommand,
+  UpdateCloudWatchAlarmTemplateCommand: () => UpdateCloudWatchAlarmTemplateCommand,
+  UpdateCloudWatchAlarmTemplateGroupCommand: () => UpdateCloudWatchAlarmTemplateGroupCommand,
+  UpdateEventBridgeRuleTemplateCommand: () => UpdateEventBridgeRuleTemplateCommand,
+  UpdateEventBridgeRuleTemplateGroupCommand: () => UpdateEventBridgeRuleTemplateGroupCommand,
   UpdateInputCommand: () => UpdateInputCommand,
   UpdateInputDeviceCommand: () => UpdateInputDeviceCommand,
   UpdateInputSecurityGroupCommand: () => UpdateInputSecurityGroupCommand,
@@ -389,6 +423,10 @@ __export(src_exports, {
   __Client: () => import_smithy_client.Client,
   paginateDescribeSchedule: () => paginateDescribeSchedule,
   paginateListChannels: () => paginateListChannels,
+  paginateListCloudWatchAlarmTemplateGroups: () => paginateListCloudWatchAlarmTemplateGroups,
+  paginateListCloudWatchAlarmTemplates: () => paginateListCloudWatchAlarmTemplates,
+  paginateListEventBridgeRuleTemplateGroups: () => paginateListEventBridgeRuleTemplateGroups,
+  paginateListEventBridgeRuleTemplates: () => paginateListEventBridgeRuleTemplates,
   paginateListInputDeviceTransfers: () => paginateListInputDeviceTransfers,
   paginateListInputDevices: () => paginateListInputDevices,
   paginateListInputSecurityGroups: () => paginateListInputSecurityGroups,
@@ -397,6 +435,7 @@ __export(src_exports, {
   paginateListMultiplexes: () => paginateListMultiplexes,
   paginateListOfferings: () => paginateListOfferings,
   paginateListReservations: () => paginateListReservations,
+  paginateListSignalMaps: () => paginateListSignalMaps,
   waitForChannelCreated: () => waitForChannelCreated,
   waitForChannelDeleted: () => waitForChannelDeleted,
   waitForChannelRunning: () => waitForChannelRunning,
@@ -408,6 +447,10 @@ __export(src_exports, {
   waitForMultiplexDeleted: () => waitForMultiplexDeleted,
   waitForMultiplexRunning: () => waitForMultiplexRunning,
   waitForMultiplexStopped: () => waitForMultiplexStopped,
+  waitForSignalMapCreated: () => waitForSignalMapCreated,
+  waitForSignalMapMonitorDeleted: () => waitForSignalMapMonitorDeleted,
+  waitForSignalMapMonitorDeployed: () => waitForSignalMapMonitorDeployed,
+  waitForSignalMapUpdated: () => waitForSignalMapUpdated,
   waitUntilChannelCreated: () => waitUntilChannelCreated,
   waitUntilChannelDeleted: () => waitUntilChannelDeleted,
   waitUntilChannelRunning: () => waitUntilChannelRunning,
@@ -418,7 +461,11 @@ __export(src_exports, {
   waitUntilMultiplexCreated: () => waitUntilMultiplexCreated,
   waitUntilMultiplexDeleted: () => waitUntilMultiplexDeleted,
   waitUntilMultiplexRunning: () => waitUntilMultiplexRunning,
-  waitUntilMultiplexStopped: () => waitUntilMultiplexStopped
+  waitUntilMultiplexStopped: () => waitUntilMultiplexStopped,
+  waitUntilSignalMapCreated: () => waitUntilSignalMapCreated,
+  waitUntilSignalMapMonitorDeleted: () => waitUntilSignalMapMonitorDeleted,
+  waitUntilSignalMapMonitorDeployed: () => waitUntilSignalMapMonitorDeployed,
+  waitUntilSignalMapUpdated: () => waitUntilSignalMapUpdated
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -595,6 +642,35 @@ __name(_MediaLiveServiceException, "MediaLiveServiceException");
 var MediaLiveServiceException = _MediaLiveServiceException;
 
 // src/models/models_1.ts
+var Scte35Type = {
+  NONE: "NONE",
+  SCTE_35_WITHOUT_SEGMENTATION: "SCTE_35_WITHOUT_SEGMENTATION"
+};
+var CmafIngestSegmentLengthUnits = {
+  MILLISECONDS: "MILLISECONDS",
+  SECONDS: "SECONDS"
+};
+var HlsCaptionLanguageSetting = {
+  INSERT: "INSERT",
+  NONE: "NONE",
+  OMIT: "OMIT"
+};
+var HlsClientCache = {
+  DISABLED: "DISABLED",
+  ENABLED: "ENABLED"
+};
+var HlsCodecSpecification = {
+  RFC_4281: "RFC_4281",
+  RFC_6381: "RFC_6381"
+};
+var HlsDirectoryStructure = {
+  SINGLE_DIRECTORY: "SINGLE_DIRECTORY",
+  SUBDIRECTORY_PER_STREAM: "SUBDIRECTORY_PER_STREAM"
+};
+var HlsDiscontinuityTags = {
+  INSERT: "INSERT",
+  NEVER_INSERT: "NEVER_INSERT"
+};
 var HlsEncryptionType = {
   AES128: "AES128",
   SAMPLE_AES: "SAMPLE_AES"
@@ -806,6 +882,29 @@ var FollowPoint = {
   END: "END",
   START: "START"
 };
+var SignalMapMonitorDeploymentStatus = {
+  DELETE_COMPLETE: "DELETE_COMPLETE",
+  DELETE_FAILED: "DELETE_FAILED",
+  DELETE_IN_PROGRESS: "DELETE_IN_PROGRESS",
+  DEPLOYMENT_COMPLETE: "DEPLOYMENT_COMPLETE",
+  DEPLOYMENT_FAILED: "DEPLOYMENT_FAILED",
+  DEPLOYMENT_IN_PROGRESS: "DEPLOYMENT_IN_PROGRESS",
+  DRY_RUN_DEPLOYMENT_COMPLETE: "DRY_RUN_DEPLOYMENT_COMPLETE",
+  DRY_RUN_DEPLOYMENT_FAILED: "DRY_RUN_DEPLOYMENT_FAILED",
+  DRY_RUN_DEPLOYMENT_IN_PROGRESS: "DRY_RUN_DEPLOYMENT_IN_PROGRESS",
+  NOT_DEPLOYED: "NOT_DEPLOYED"
+};
+var SignalMapStatus = {
+  CREATE_COMPLETE: "CREATE_COMPLETE",
+  CREATE_FAILED: "CREATE_FAILED",
+  CREATE_IN_PROGRESS: "CREATE_IN_PROGRESS",
+  NOT_READY: "NOT_READY",
+  READY: "READY",
+  UPDATE_COMPLETE: "UPDATE_COMPLETE",
+  UPDATE_FAILED: "UPDATE_FAILED",
+  UPDATE_IN_PROGRESS: "UPDATE_IN_PROGRESS",
+  UPDATE_REVERTED: "UPDATE_REVERTED"
+};
 var ThumbnailType = {
   CURRENT_ACTIVE: "CURRENT_ACTIVE",
   UNSPECIFIED: "UNSPECIFIED"
@@ -1366,9 +1465,6 @@ var PreferredChannelPipeline = {
   PIPELINE_0: "PIPELINE_0",
   PIPELINE_1: "PIPELINE_1"
 };
-var DescribeInputDeviceThumbnailResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
-  ...obj
-}), "DescribeInputDeviceThumbnailResponseFilterSensitiveLog");
 
 // src/protocols/Aws_restJson1.ts
 var se_AcceptInputDeviceTransferCommand = /* @__PURE__ */ __name(async (input, context) => {
@@ -1499,6 +1595,87 @@ var se_CreateChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_CreateChannelCommand");
+var se_CreateCloudWatchAlarmTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prod/cloudwatch-alarm-templates");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      comparisonOperator: [, , `ComparisonOperator`],
+      datapointsToAlarm: [, , `DatapointsToAlarm`],
+      description: [, , `Description`],
+      evaluationPeriods: [, , `EvaluationPeriods`],
+      groupIdentifier: [, , `GroupIdentifier`],
+      metricName: [, , `MetricName`],
+      name: [, , `Name`],
+      period: [, , `Period`],
+      statistic: [, , `Statistic`],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`],
+      targetResourceType: [, , `TargetResourceType`],
+      threshold: [, (_) => (0, import_smithy_client.serializeFloat)(_), `Threshold`],
+      treatMissingData: [, , `TreatMissingData`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateCloudWatchAlarmTemplateCommand");
+var se_CreateCloudWatchAlarmTemplateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prod/cloudwatch-alarm-template-groups");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      description: [, , `Description`],
+      name: [, , `Name`],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateCloudWatchAlarmTemplateGroupCommand");
+var se_CreateEventBridgeRuleTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prod/eventbridge-rule-templates");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      description: [, , `Description`],
+      eventTargets: [, (_) => se___listOfEventBridgeRuleTemplateTarget(_, context), `EventTargets`],
+      eventType: [, , `EventType`],
+      groupIdentifier: [, , `GroupIdentifier`],
+      name: [, , `Name`],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateEventBridgeRuleTemplateCommand");
+var se_CreateEventBridgeRuleTemplateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prod/eventbridge-rule-template-groups");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      description: [, , `Description`],
+      name: [, , `Name`],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateEventBridgeRuleTemplateGroupCommand");
 var se_CreateInputCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -1594,6 +1771,26 @@ var se_CreatePartnerInputCommand = /* @__PURE__ */ __name(async (input, context)
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_CreatePartnerInputCommand");
+var se_CreateSignalMapCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prod/signal-maps");
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      cloudWatchAlarmTemplateGroupIdentifiers: [, (_) => (0, import_smithy_client._json)(_), `CloudWatchAlarmTemplateGroupIdentifiers`],
+      description: [, , `Description`],
+      discoveryEntryPointArn: [, , `DiscoveryEntryPointArn`],
+      eventBridgeRuleTemplateGroupIdentifiers: [, (_) => (0, import_smithy_client._json)(_), `EventBridgeRuleTemplateGroupIdentifiers`],
+      name: [, , `Name`],
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_CreateSignalMapCommand");
 var se_CreateTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
@@ -1619,6 +1816,42 @@ var se_DeleteChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("DELETE").h(headers).b(body);
   return b.build();
 }, "se_DeleteChannelCommand");
+var se_DeleteCloudWatchAlarmTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/cloudwatch-alarm-templates/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteCloudWatchAlarmTemplateCommand");
+var se_DeleteCloudWatchAlarmTemplateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/cloudwatch-alarm-template-groups/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteCloudWatchAlarmTemplateGroupCommand");
+var se_DeleteEventBridgeRuleTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/eventbridge-rule-templates/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteEventBridgeRuleTemplateCommand");
+var se_DeleteEventBridgeRuleTemplateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/eventbridge-rule-template-groups/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteEventBridgeRuleTemplateGroupCommand");
 var se_DeleteInputCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -1674,6 +1907,15 @@ var se_DeleteScheduleCommand = /* @__PURE__ */ __name(async (input, context) =>
   b.m("DELETE").h(headers).b(body);
   return b.build();
 }, "se_DeleteScheduleCommand");
+var se_DeleteSignalMapCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/signal-maps/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_DeleteSignalMapCommand");
 var se_DeleteTagsCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -1810,6 +2052,51 @@ var se_DescribeThumbnailsCommand = /* @__PURE__ */ __name(async (input, context)
   b.m("GET").h(headers).q(query).b(body);
   return b.build();
 }, "se_DescribeThumbnailsCommand");
+var se_GetCloudWatchAlarmTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/cloudwatch-alarm-templates/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetCloudWatchAlarmTemplateCommand");
+var se_GetCloudWatchAlarmTemplateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/cloudwatch-alarm-template-groups/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetCloudWatchAlarmTemplateGroupCommand");
+var se_GetEventBridgeRuleTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/eventbridge-rule-templates/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetEventBridgeRuleTemplateCommand");
+var se_GetEventBridgeRuleTemplateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/eventbridge-rule-template-groups/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetEventBridgeRuleTemplateGroupCommand");
+var se_GetSignalMapCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/signal-maps/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  b.m("GET").h(headers).b(body);
+  return b.build();
+}, "se_GetSignalMapCommand");
 var se_ListChannelsCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -1822,6 +2109,62 @@ var se_ListChannelsCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("GET").h(headers).q(query).b(body);
   return b.build();
 }, "se_ListChannelsCommand");
+var se_ListCloudWatchAlarmTemplateGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/cloudwatch-alarm-template-groups");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]],
+    [_s]: [, input[_S]],
+    [_sMI]: [, input[_SMI]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListCloudWatchAlarmTemplateGroupsCommand");
+var se_ListCloudWatchAlarmTemplatesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/cloudwatch-alarm-templates");
+  const query = (0, import_smithy_client.map)({
+    [_gI]: [, input[_GI]],
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]],
+    [_s]: [, input[_S]],
+    [_sMI]: [, input[_SMI]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListCloudWatchAlarmTemplatesCommand");
+var se_ListEventBridgeRuleTemplateGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/eventbridge-rule-template-groups");
+  const query = (0, import_smithy_client.map)({
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]],
+    [_sMI]: [, input[_SMI]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListEventBridgeRuleTemplateGroupsCommand");
+var se_ListEventBridgeRuleTemplatesCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/eventbridge-rule-templates");
+  const query = (0, import_smithy_client.map)({
+    [_gI]: [, input[_GI]],
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]],
+    [_sMI]: [, input[_SMI]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListEventBridgeRuleTemplatesCommand");
 var se_ListInputDevicesCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -1938,6 +2281,20 @@ var se_ListReservationsCommand = /* @__PURE__ */ __name(async (input, context) =
   b.m("GET").h(headers).q(query).b(body);
   return b.build();
 }, "se_ListReservationsCommand");
+var se_ListSignalMapsCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/signal-maps");
+  const query = (0, import_smithy_client.map)({
+    [_cWATGI]: [, input[_CWATGI]],
+    [_eBRTGI]: [, input[_EBRTGI]],
+    [_mR]: [() => input.MaxResults !== void 0, () => input[_MR].toString()],
+    [_nT]: [, input[_NT]]
+  });
+  let body;
+  b.m("GET").h(headers).q(query).b(body);
+  return b.build();
+}, "se_ListSignalMapsCommand");
 var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -2018,6 +2375,15 @@ var se_StartChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_StartChannelCommand");
+var se_StartDeleteMonitorDeploymentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {};
+  b.bp("/prod/signal-maps/{Identifier}/monitor-deployment");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  b.m("DELETE").h(headers).b(body);
+  return b.build();
+}, "se_StartDeleteMonitorDeploymentCommand");
 var se_StartInputDeviceCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -2036,6 +2402,22 @@ var se_StartInputDeviceMaintenanceWindowCommand = /* @__PURE__ */ __name(async (
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_StartInputDeviceMaintenanceWindowCommand");
+var se_StartMonitorDeploymentCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prod/signal-maps/{Identifier}/monitor-deployment");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      dryRun: [, , `DryRun`]
+    })
+  );
+  b.m("POST").h(headers).b(body);
+  return b.build();
+}, "se_StartMonitorDeploymentCommand");
 var se_StartMultiplexCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -2045,6 +2427,27 @@ var se_StartMultiplexCommand = /* @__PURE__ */ __name(async (input, context) =>
   b.m("POST").h(headers).b(body);
   return b.build();
 }, "se_StartMultiplexCommand");
+var se_StartUpdateSignalMapCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prod/signal-maps/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      cloudWatchAlarmTemplateGroupIdentifiers: [, (_) => (0, import_smithy_client._json)(_), `CloudWatchAlarmTemplateGroupIdentifiers`],
+      description: [, , `Description`],
+      discoveryEntryPointArn: [, , `DiscoveryEntryPointArn`],
+      eventBridgeRuleTemplateGroupIdentifiers: [, (_) => (0, import_smithy_client._json)(_), `EventBridgeRuleTemplateGroupIdentifiers`],
+      forceRediscovery: [, , `ForceRediscovery`],
+      name: [, , `Name`]
+    })
+  );
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_StartUpdateSignalMapCommand");
 var se_StopChannelCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {};
@@ -2146,79 +2549,158 @@ var se_UpdateChannelClassCommand = /* @__PURE__ */ __name(async (input, context)
   b.m("PUT").h(headers).b(body);
   return b.build();
 }, "se_UpdateChannelClassCommand");
-var se_UpdateInputCommand = /* @__PURE__ */ __name(async (input, context) => {
+var se_UpdateCloudWatchAlarmTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
     "content-type": "application/json"
   };
-  b.bp("/prod/inputs/{InputId}");
-  b.p("InputId", () => input.InputId, "{InputId}", false);
+  b.bp("/prod/cloudwatch-alarm-templates/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
   let body;
   body = JSON.stringify(
     (0, import_smithy_client.take)(input, {
-      destinations: [, (_) => se___listOfInputDestinationRequest(_, context), `Destinations`],
-      inputDevices: [, (_) => se___listOfInputDeviceRequest(_, context), `InputDevices`],
-      inputSecurityGroups: [, (_) => (0, import_smithy_client._json)(_), `InputSecurityGroups`],
-      mediaConnectFlows: [, (_) => se___listOfMediaConnectFlowRequest(_, context), `MediaConnectFlows`],
+      comparisonOperator: [, , `ComparisonOperator`],
+      datapointsToAlarm: [, , `DatapointsToAlarm`],
+      description: [, , `Description`],
+      evaluationPeriods: [, , `EvaluationPeriods`],
+      groupIdentifier: [, , `GroupIdentifier`],
+      metricName: [, , `MetricName`],
       name: [, , `Name`],
-      roleArn: [, , `RoleArn`],
-      sources: [, (_) => se___listOfInputSourceRequest(_, context), `Sources`]
+      period: [, , `Period`],
+      statistic: [, , `Statistic`],
+      targetResourceType: [, , `TargetResourceType`],
+      threshold: [, (_) => (0, import_smithy_client.serializeFloat)(_), `Threshold`],
+      treatMissingData: [, , `TreatMissingData`]
     })
   );
-  b.m("PUT").h(headers).b(body);
+  b.m("PATCH").h(headers).b(body);
   return b.build();
-}, "se_UpdateInputCommand");
-var se_UpdateInputDeviceCommand = /* @__PURE__ */ __name(async (input, context) => {
+}, "se_UpdateCloudWatchAlarmTemplateCommand");
+var se_UpdateCloudWatchAlarmTemplateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
     "content-type": "application/json"
   };
-  b.bp("/prod/inputDevices/{InputDeviceId}");
-  b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+  b.bp("/prod/cloudwatch-alarm-template-groups/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
   let body;
   body = JSON.stringify(
     (0, import_smithy_client.take)(input, {
-      availabilityZone: [, , `AvailabilityZone`],
-      hdDeviceSettings: [, (_) => se_InputDeviceConfigurableSettings(_, context), `HdDeviceSettings`],
-      name: [, , `Name`],
-      uhdDeviceSettings: [, (_) => se_InputDeviceConfigurableSettings(_, context), `UhdDeviceSettings`]
+      description: [, , `Description`]
     })
   );
-  b.m("PUT").h(headers).b(body);
+  b.m("PATCH").h(headers).b(body);
   return b.build();
-}, "se_UpdateInputDeviceCommand");
-var se_UpdateInputSecurityGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+}, "se_UpdateCloudWatchAlarmTemplateGroupCommand");
+var se_UpdateEventBridgeRuleTemplateCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
     "content-type": "application/json"
   };
-  b.bp("/prod/inputSecurityGroups/{InputSecurityGroupId}");
-  b.p("InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
+  b.bp("/prod/eventbridge-rule-templates/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
   let body;
   body = JSON.stringify(
     (0, import_smithy_client.take)(input, {
-      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`],
-      whitelistRules: [, (_) => se___listOfInputWhitelistRuleCidr(_, context), `WhitelistRules`]
+      description: [, , `Description`],
+      eventTargets: [, (_) => se___listOfEventBridgeRuleTemplateTarget(_, context), `EventTargets`],
+      eventType: [, , `EventType`],
+      groupIdentifier: [, , `GroupIdentifier`],
+      name: [, , `Name`]
     })
   );
-  b.m("PUT").h(headers).b(body);
+  b.m("PATCH").h(headers).b(body);
   return b.build();
-}, "se_UpdateInputSecurityGroupCommand");
-var se_UpdateMultiplexCommand = /* @__PURE__ */ __name(async (input, context) => {
+}, "se_UpdateEventBridgeRuleTemplateCommand");
+var se_UpdateEventBridgeRuleTemplateGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
   const b = (0, import_core.requestBuilder)(input, context);
   const headers = {
     "content-type": "application/json"
   };
-  b.bp("/prod/multiplexes/{MultiplexId}");
-  b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+  b.bp("/prod/eventbridge-rule-template-groups/{Identifier}");
+  b.p("Identifier", () => input.Identifier, "{Identifier}", false);
   let body;
   body = JSON.stringify(
     (0, import_smithy_client.take)(input, {
-      multiplexSettings: [, (_) => se_MultiplexSettings(_, context), `MultiplexSettings`],
-      name: [, , `Name`]
+      description: [, , `Description`]
     })
   );
-  b.m("PUT").h(headers).b(body);
+  b.m("PATCH").h(headers).b(body);
+  return b.build();
+}, "se_UpdateEventBridgeRuleTemplateGroupCommand");
+var se_UpdateInputCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prod/inputs/{InputId}");
+  b.p("InputId", () => input.InputId, "{InputId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      destinations: [, (_) => se___listOfInputDestinationRequest(_, context), `Destinations`],
+      inputDevices: [, (_) => se___listOfInputDeviceRequest(_, context), `InputDevices`],
+      inputSecurityGroups: [, (_) => (0, import_smithy_client._json)(_), `InputSecurityGroups`],
+      mediaConnectFlows: [, (_) => se___listOfMediaConnectFlowRequest(_, context), `MediaConnectFlows`],
+      name: [, , `Name`],
+      roleArn: [, , `RoleArn`],
+      sources: [, (_) => se___listOfInputSourceRequest(_, context), `Sources`]
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateInputCommand");
+var se_UpdateInputDeviceCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prod/inputDevices/{InputDeviceId}");
+  b.p("InputDeviceId", () => input.InputDeviceId, "{InputDeviceId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      availabilityZone: [, , `AvailabilityZone`],
+      hdDeviceSettings: [, (_) => se_InputDeviceConfigurableSettings(_, context), `HdDeviceSettings`],
+      name: [, , `Name`],
+      uhdDeviceSettings: [, (_) => se_InputDeviceConfigurableSettings(_, context), `UhdDeviceSettings`]
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateInputDeviceCommand");
+var se_UpdateInputSecurityGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prod/inputSecurityGroups/{InputSecurityGroupId}");
+  b.p("InputSecurityGroupId", () => input.InputSecurityGroupId, "{InputSecurityGroupId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      tags: [, (_) => (0, import_smithy_client._json)(_), `Tags`],
+      whitelistRules: [, (_) => se___listOfInputWhitelistRuleCidr(_, context), `WhitelistRules`]
+    })
+  );
+  b.m("PUT").h(headers).b(body);
+  return b.build();
+}, "se_UpdateInputSecurityGroupCommand");
+var se_UpdateMultiplexCommand = /* @__PURE__ */ __name(async (input, context) => {
+  const b = (0, import_core.requestBuilder)(input, context);
+  const headers = {
+    "content-type": "application/json"
+  };
+  b.bp("/prod/multiplexes/{MultiplexId}");
+  b.p("MultiplexId", () => input.MultiplexId, "{MultiplexId}", false);
+  let body;
+  body = JSON.stringify(
+    (0, import_smithy_client.take)(input, {
+      multiplexSettings: [, (_) => se_MultiplexSettings(_, context), `MultiplexSettings`],
+      name: [, , `Name`]
+    })
+  );
+  b.m("PUT").h(headers).b(body);
   return b.build();
 }, "se_UpdateMultiplexCommand");
 var se_UpdateMultiplexProgramCommand = /* @__PURE__ */ __name(async (input, context) => {
@@ -2359,6 +2841,99 @@ var de_CreateChannelCommand = /* @__PURE__ */ __name(async (output, context) =>
   Object.assign(contents, doc);
   return contents;
 }, "de_CreateChannelCommand");
+var de_CreateCloudWatchAlarmTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    ComparisonOperator: [, import_smithy_client.expectString, `comparisonOperator`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    DatapointsToAlarm: [, import_smithy_client.expectInt32, `datapointsToAlarm`],
+    Description: [, import_smithy_client.expectString, `description`],
+    EvaluationPeriods: [, import_smithy_client.expectInt32, `evaluationPeriods`],
+    GroupId: [, import_smithy_client.expectString, `groupId`],
+    Id: [, import_smithy_client.expectString, `id`],
+    MetricName: [, import_smithy_client.expectString, `metricName`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Period: [, import_smithy_client.expectInt32, `period`],
+    Statistic: [, import_smithy_client.expectString, `statistic`],
+    Tags: [, import_smithy_client._json, `tags`],
+    TargetResourceType: [, import_smithy_client.expectString, `targetResourceType`],
+    Threshold: [, import_smithy_client.limitedParseDouble, `threshold`],
+    TreatMissingData: [, import_smithy_client.expectString, `treatMissingData`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateCloudWatchAlarmTemplateCommand");
+var de_CreateCloudWatchAlarmTemplateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateCloudWatchAlarmTemplateGroupCommand");
+var de_CreateEventBridgeRuleTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    EventTargets: [, (_) => de___listOfEventBridgeRuleTemplateTarget(_, context), `eventTargets`],
+    EventType: [, import_smithy_client.expectString, `eventType`],
+    GroupId: [, import_smithy_client.expectString, `groupId`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateEventBridgeRuleTemplateCommand");
+var de_CreateEventBridgeRuleTemplateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateEventBridgeRuleTemplateGroupCommand");
 var de_CreateInputCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 201 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -2429,6 +3004,41 @@ var de_CreatePartnerInputCommand = /* @__PURE__ */ __name(async (output, context
   Object.assign(contents, doc);
   return contents;
 }, "de_CreatePartnerInputCommand");
+var de_CreateSignalMapCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 201 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CloudWatchAlarmTemplateGroupIds: [, import_smithy_client._json, `cloudWatchAlarmTemplateGroupIds`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    DiscoveryEntryPointArn: [, import_smithy_client.expectString, `discoveryEntryPointArn`],
+    ErrorMessage: [, import_smithy_client.expectString, `errorMessage`],
+    EventBridgeRuleTemplateGroupIds: [, import_smithy_client._json, `eventBridgeRuleTemplateGroupIds`],
+    FailedMediaResourceMap: [, (_) => de_FailedMediaResourceMap(_, context), `failedMediaResourceMap`],
+    Id: [, import_smithy_client.expectString, `id`],
+    LastDiscoveredAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `lastDiscoveredAt`],
+    LastSuccessfulMonitorDeployment: [
+      ,
+      (_) => de_SuccessfulMonitorDeployment(_, context),
+      `lastSuccessfulMonitorDeployment`
+    ],
+    MediaResourceMap: [, (_) => de_MediaResourceMap(_, context), `mediaResourceMap`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    MonitorChangesPendingDeployment: [, import_smithy_client.expectBoolean, `monitorChangesPendingDeployment`],
+    MonitorDeployment: [, (_) => de_MonitorDeployment(_, context), `monitorDeployment`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Status: [, import_smithy_client.expectString, `status`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_CreateSignalMapCommand");
 var de_CreateTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 204 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -2470,6 +3080,46 @@ var de_DeleteChannelCommand = /* @__PURE__ */ __name(async (output, context) =>
   Object.assign(contents, doc);
   return contents;
 }, "de_DeleteChannelCommand");
+var de_DeleteCloudWatchAlarmTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteCloudWatchAlarmTemplateCommand");
+var de_DeleteCloudWatchAlarmTemplateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteCloudWatchAlarmTemplateGroupCommand");
+var de_DeleteEventBridgeRuleTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteEventBridgeRuleTemplateCommand");
+var de_DeleteEventBridgeRuleTemplateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteEventBridgeRuleTemplateGroupCommand");
 var de_DeleteInputCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -2573,6 +3223,16 @@ var de_DeleteScheduleCommand = /* @__PURE__ */ __name(async (output, context) =>
   await (0, import_smithy_client.collectBody)(output.body, context);
   return contents;
 }, "de_DeleteScheduleCommand");
+var de_DeleteSignalMapCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 204 && output.statusCode >= 300) {
+    return de_CommandError(output, context);
+  }
+  const contents = (0, import_smithy_client.map)({
+    $metadata: deserializeMetadata(output)
+  });
+  await (0, import_smithy_client.collectBody)(output.body, context);
+  return contents;
+}, "de_DeleteSignalMapCommand");
 var de_DeleteTagsCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 204 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -2847,7 +3507,7 @@ var de_DescribeThumbnailsCommand = /* @__PURE__ */ __name(async (output, context
   Object.assign(contents, doc);
   return contents;
 }, "de_DescribeThumbnailsCommand");
-var de_ListChannelsCommand = /* @__PURE__ */ __name(async (output, context) => {
+var de_GetCloudWatchAlarmTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
   }
@@ -2856,13 +3516,28 @@ var de_ListChannelsCommand = /* @__PURE__ */ __name(async (output, context) => {
   });
   const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
   const doc = (0, import_smithy_client.take)(data, {
-    Channels: [, (_) => de___listOfChannelSummary(_, context), `channels`],
-    NextToken: [, import_smithy_client.expectString, `nextToken`]
+    Arn: [, import_smithy_client.expectString, `arn`],
+    ComparisonOperator: [, import_smithy_client.expectString, `comparisonOperator`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    DatapointsToAlarm: [, import_smithy_client.expectInt32, `datapointsToAlarm`],
+    Description: [, import_smithy_client.expectString, `description`],
+    EvaluationPeriods: [, import_smithy_client.expectInt32, `evaluationPeriods`],
+    GroupId: [, import_smithy_client.expectString, `groupId`],
+    Id: [, import_smithy_client.expectString, `id`],
+    MetricName: [, import_smithy_client.expectString, `metricName`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Period: [, import_smithy_client.expectInt32, `period`],
+    Statistic: [, import_smithy_client.expectString, `statistic`],
+    Tags: [, import_smithy_client._json, `tags`],
+    TargetResourceType: [, import_smithy_client.expectString, `targetResourceType`],
+    Threshold: [, import_smithy_client.limitedParseDouble, `threshold`],
+    TreatMissingData: [, import_smithy_client.expectString, `treatMissingData`]
   });
   Object.assign(contents, doc);
   return contents;
-}, "de_ListChannelsCommand");
-var de_ListInputDevicesCommand = /* @__PURE__ */ __name(async (output, context) => {
+}, "de_GetCloudWatchAlarmTemplateCommand");
+var de_GetCloudWatchAlarmTemplateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
   }
@@ -2871,13 +3546,18 @@ var de_ListInputDevicesCommand = /* @__PURE__ */ __name(async (output, context)
   });
   const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
   const doc = (0, import_smithy_client.take)(data, {
-    InputDevices: [, (_) => de___listOfInputDeviceSummary(_, context), `inputDevices`],
-    NextToken: [, import_smithy_client.expectString, `nextToken`]
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`]
   });
   Object.assign(contents, doc);
   return contents;
-}, "de_ListInputDevicesCommand");
-var de_ListInputDeviceTransfersCommand = /* @__PURE__ */ __name(async (output, context) => {
+}, "de_GetCloudWatchAlarmTemplateGroupCommand");
+var de_GetEventBridgeRuleTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
   }
@@ -2886,13 +3566,21 @@ var de_ListInputDeviceTransfersCommand = /* @__PURE__ */ __name(async (output, c
   });
   const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
   const doc = (0, import_smithy_client.take)(data, {
-    InputDeviceTransfers: [, (_) => de___listOfTransferringInputDeviceSummary(_, context), `inputDeviceTransfers`],
-    NextToken: [, import_smithy_client.expectString, `nextToken`]
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    EventTargets: [, (_) => de___listOfEventBridgeRuleTemplateTarget(_, context), `eventTargets`],
+    EventType: [, import_smithy_client.expectString, `eventType`],
+    GroupId: [, import_smithy_client.expectString, `groupId`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`]
   });
   Object.assign(contents, doc);
   return contents;
-}, "de_ListInputDeviceTransfersCommand");
-var de_ListInputsCommand = /* @__PURE__ */ __name(async (output, context) => {
+}, "de_GetEventBridgeRuleTemplateCommand");
+var de_GetEventBridgeRuleTemplateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
   }
@@ -2901,13 +3589,18 @@ var de_ListInputsCommand = /* @__PURE__ */ __name(async (output, context) => {
   });
   const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
   const doc = (0, import_smithy_client.take)(data, {
-    Inputs: [, (_) => de___listOfInput(_, context), `inputs`],
-    NextToken: [, import_smithy_client.expectString, `nextToken`]
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`]
   });
   Object.assign(contents, doc);
   return contents;
-}, "de_ListInputsCommand");
-var de_ListInputSecurityGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+}, "de_GetEventBridgeRuleTemplateGroupCommand");
+var de_GetSignalMapCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
   }
@@ -2916,13 +3609,33 @@ var de_ListInputSecurityGroupsCommand = /* @__PURE__ */ __name(async (output, co
   });
   const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
   const doc = (0, import_smithy_client.take)(data, {
-    InputSecurityGroups: [, (_) => de___listOfInputSecurityGroup(_, context), `inputSecurityGroups`],
-    NextToken: [, import_smithy_client.expectString, `nextToken`]
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CloudWatchAlarmTemplateGroupIds: [, import_smithy_client._json, `cloudWatchAlarmTemplateGroupIds`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    DiscoveryEntryPointArn: [, import_smithy_client.expectString, `discoveryEntryPointArn`],
+    ErrorMessage: [, import_smithy_client.expectString, `errorMessage`],
+    EventBridgeRuleTemplateGroupIds: [, import_smithy_client._json, `eventBridgeRuleTemplateGroupIds`],
+    FailedMediaResourceMap: [, (_) => de_FailedMediaResourceMap(_, context), `failedMediaResourceMap`],
+    Id: [, import_smithy_client.expectString, `id`],
+    LastDiscoveredAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `lastDiscoveredAt`],
+    LastSuccessfulMonitorDeployment: [
+      ,
+      (_) => de_SuccessfulMonitorDeployment(_, context),
+      `lastSuccessfulMonitorDeployment`
+    ],
+    MediaResourceMap: [, (_) => de_MediaResourceMap(_, context), `mediaResourceMap`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    MonitorChangesPendingDeployment: [, import_smithy_client.expectBoolean, `monitorChangesPendingDeployment`],
+    MonitorDeployment: [, (_) => de_MonitorDeployment(_, context), `monitorDeployment`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Status: [, import_smithy_client.expectString, `status`],
+    Tags: [, import_smithy_client._json, `tags`]
   });
   Object.assign(contents, doc);
   return contents;
-}, "de_ListInputSecurityGroupsCommand");
-var de_ListMultiplexesCommand = /* @__PURE__ */ __name(async (output, context) => {
+}, "de_GetSignalMapCommand");
+var de_ListChannelsCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
   }
@@ -2931,13 +3644,13 @@ var de_ListMultiplexesCommand = /* @__PURE__ */ __name(async (output, context) =
   });
   const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
   const doc = (0, import_smithy_client.take)(data, {
-    Multiplexes: [, (_) => de___listOfMultiplexSummary(_, context), `multiplexes`],
+    Channels: [, (_) => de___listOfChannelSummary(_, context), `channels`],
     NextToken: [, import_smithy_client.expectString, `nextToken`]
   });
   Object.assign(contents, doc);
   return contents;
-}, "de_ListMultiplexesCommand");
-var de_ListMultiplexProgramsCommand = /* @__PURE__ */ __name(async (output, context) => {
+}, "de_ListChannelsCommand");
+var de_ListCloudWatchAlarmTemplateGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
   }
@@ -2946,13 +3659,17 @@ var de_ListMultiplexProgramsCommand = /* @__PURE__ */ __name(async (output, cont
   });
   const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
   const doc = (0, import_smithy_client.take)(data, {
-    MultiplexPrograms: [, (_) => de___listOfMultiplexProgramSummary(_, context), `multiplexPrograms`],
+    CloudWatchAlarmTemplateGroups: [
+      ,
+      (_) => de___listOfCloudWatchAlarmTemplateGroupSummary(_, context),
+      `cloudWatchAlarmTemplateGroups`
+    ],
     NextToken: [, import_smithy_client.expectString, `nextToken`]
   });
   Object.assign(contents, doc);
   return contents;
-}, "de_ListMultiplexProgramsCommand");
-var de_ListOfferingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+}, "de_ListCloudWatchAlarmTemplateGroupsCommand");
+var de_ListCloudWatchAlarmTemplatesCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
   }
@@ -2961,13 +3678,160 @@ var de_ListOfferingsCommand = /* @__PURE__ */ __name(async (output, context) =>
   });
   const data = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.expectObject)(await (0, import_core2.parseJsonBody)(output.body, context)), "body");
   const doc = (0, import_smithy_client.take)(data, {
-    NextToken: [, import_smithy_client.expectString, `nextToken`],
-    Offerings: [, (_) => de___listOfOffering(_, context), `offerings`]
+    CloudWatchAlarmTemplates: [
+      ,
+      (_) => de___listOfCloudWatchAlarmTemplateSummary(_, context),
+      `cloudWatchAlarmTemplates`
+    ],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
   });
   Object.assign(contents, doc);
   return contents;
-}, "de_ListOfferingsCommand");
-var de_ListReservationsCommand = /* @__PURE__ */ __name(async (output, context) => {
+}, "de_ListCloudWatchAlarmTemplatesCommand");
+var de_ListEventBridgeRuleTemplateGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    EventBridgeRuleTemplateGroups: [
+      ,
+      (_) => de___listOfEventBridgeRuleTemplateGroupSummary(_, context),
+      `eventBridgeRuleTemplateGroups`
+    ],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListEventBridgeRuleTemplateGroupsCommand");
+var de_ListEventBridgeRuleTemplatesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    EventBridgeRuleTemplates: [
+      ,
+      (_) => de___listOfEventBridgeRuleTemplateSummary(_, context),
+      `eventBridgeRuleTemplates`
+    ],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListEventBridgeRuleTemplatesCommand");
+var de_ListInputDevicesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    InputDevices: [, (_) => de___listOfInputDeviceSummary(_, context), `inputDevices`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListInputDevicesCommand");
+var de_ListInputDeviceTransfersCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    InputDeviceTransfers: [, (_) => de___listOfTransferringInputDeviceSummary(_, context), `inputDeviceTransfers`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListInputDeviceTransfersCommand");
+var de_ListInputsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Inputs: [, (_) => de___listOfInput(_, context), `inputs`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListInputsCommand");
+var de_ListInputSecurityGroupsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    InputSecurityGroups: [, (_) => de___listOfInputSecurityGroup(_, context), `inputSecurityGroups`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListInputSecurityGroupsCommand");
+var de_ListMultiplexesCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Multiplexes: [, (_) => de___listOfMultiplexSummary(_, context), `multiplexes`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListMultiplexesCommand");
+var de_ListMultiplexProgramsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    MultiplexPrograms: [, (_) => de___listOfMultiplexProgramSummary(_, context), `multiplexPrograms`],
+    NextToken: [, import_smithy_client.expectString, `nextToken`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListMultiplexProgramsCommand");
+var de_ListOfferingsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: [, import_smithy_client.expectString, `nextToken`],
+    Offerings: [, (_) => de___listOfOffering(_, context), `offerings`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListOfferingsCommand");
+var de_ListReservationsCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
   }
@@ -2982,6 +3846,21 @@ var de_ListReservationsCommand = /* @__PURE__ */ __name(async (output, context)
   Object.assign(contents, doc);
   return contents;
 }, "de_ListReservationsCommand");
+var de_ListSignalMapsCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    NextToken: [, import_smithy_client.expectString, `nextToken`],
+    SignalMaps: [, (_) => de___listOfSignalMapSummary(_, context), `signalMaps`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_ListSignalMapsCommand");
 var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -3093,6 +3972,41 @@ var de_StartChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
   Object.assign(contents, doc);
   return contents;
 }, "de_StartChannelCommand");
+var de_StartDeleteMonitorDeploymentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 202 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CloudWatchAlarmTemplateGroupIds: [, import_smithy_client._json, `cloudWatchAlarmTemplateGroupIds`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    DiscoveryEntryPointArn: [, import_smithy_client.expectString, `discoveryEntryPointArn`],
+    ErrorMessage: [, import_smithy_client.expectString, `errorMessage`],
+    EventBridgeRuleTemplateGroupIds: [, import_smithy_client._json, `eventBridgeRuleTemplateGroupIds`],
+    FailedMediaResourceMap: [, (_) => de_FailedMediaResourceMap(_, context), `failedMediaResourceMap`],
+    Id: [, import_smithy_client.expectString, `id`],
+    LastDiscoveredAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `lastDiscoveredAt`],
+    LastSuccessfulMonitorDeployment: [
+      ,
+      (_) => de_SuccessfulMonitorDeployment(_, context),
+      `lastSuccessfulMonitorDeployment`
+    ],
+    MediaResourceMap: [, (_) => de_MediaResourceMap(_, context), `mediaResourceMap`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    MonitorChangesPendingDeployment: [, import_smithy_client.expectBoolean, `monitorChangesPendingDeployment`],
+    MonitorDeployment: [, (_) => de_MonitorDeployment(_, context), `monitorDeployment`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Status: [, import_smithy_client.expectString, `status`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartDeleteMonitorDeploymentCommand");
 var de_StartInputDeviceCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -3113,6 +4027,41 @@ var de_StartInputDeviceMaintenanceWindowCommand = /* @__PURE__ */ __name(async (
   await (0, import_smithy_client.collectBody)(output.body, context);
   return contents;
 }, "de_StartInputDeviceMaintenanceWindowCommand");
+var de_StartMonitorDeploymentCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 202 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CloudWatchAlarmTemplateGroupIds: [, import_smithy_client._json, `cloudWatchAlarmTemplateGroupIds`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    DiscoveryEntryPointArn: [, import_smithy_client.expectString, `discoveryEntryPointArn`],
+    ErrorMessage: [, import_smithy_client.expectString, `errorMessage`],
+    EventBridgeRuleTemplateGroupIds: [, import_smithy_client._json, `eventBridgeRuleTemplateGroupIds`],
+    FailedMediaResourceMap: [, (_) => de_FailedMediaResourceMap(_, context), `failedMediaResourceMap`],
+    Id: [, import_smithy_client.expectString, `id`],
+    LastDiscoveredAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `lastDiscoveredAt`],
+    LastSuccessfulMonitorDeployment: [
+      ,
+      (_) => de_SuccessfulMonitorDeployment(_, context),
+      `lastSuccessfulMonitorDeployment`
+    ],
+    MediaResourceMap: [, (_) => de_MediaResourceMap(_, context), `mediaResourceMap`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    MonitorChangesPendingDeployment: [, import_smithy_client.expectBoolean, `monitorChangesPendingDeployment`],
+    MonitorDeployment: [, (_) => de_MonitorDeployment(_, context), `monitorDeployment`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Status: [, import_smithy_client.expectString, `status`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartMonitorDeploymentCommand");
 var de_StartMultiplexCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 202 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -3136,6 +4085,41 @@ var de_StartMultiplexCommand = /* @__PURE__ */ __name(async (output, context) =>
   Object.assign(contents, doc);
   return contents;
 }, "de_StartMultiplexCommand");
+var de_StartUpdateSignalMapCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 202 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CloudWatchAlarmTemplateGroupIds: [, import_smithy_client._json, `cloudWatchAlarmTemplateGroupIds`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    DiscoveryEntryPointArn: [, import_smithy_client.expectString, `discoveryEntryPointArn`],
+    ErrorMessage: [, import_smithy_client.expectString, `errorMessage`],
+    EventBridgeRuleTemplateGroupIds: [, import_smithy_client._json, `eventBridgeRuleTemplateGroupIds`],
+    FailedMediaResourceMap: [, (_) => de_FailedMediaResourceMap(_, context), `failedMediaResourceMap`],
+    Id: [, import_smithy_client.expectString, `id`],
+    LastDiscoveredAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `lastDiscoveredAt`],
+    LastSuccessfulMonitorDeployment: [
+      ,
+      (_) => de_SuccessfulMonitorDeployment(_, context),
+      `lastSuccessfulMonitorDeployment`
+    ],
+    MediaResourceMap: [, (_) => de_MediaResourceMap(_, context), `mediaResourceMap`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    MonitorChangesPendingDeployment: [, import_smithy_client.expectBoolean, `monitorChangesPendingDeployment`],
+    MonitorDeployment: [, (_) => de_MonitorDeployment(_, context), `monitorDeployment`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Status: [, import_smithy_client.expectString, `status`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_StartUpdateSignalMapCommand");
 var de_StopChannelCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -3252,6 +4236,99 @@ var de_UpdateChannelClassCommand = /* @__PURE__ */ __name(async (output, context
   Object.assign(contents, doc);
   return contents;
 }, "de_UpdateChannelClassCommand");
+var de_UpdateCloudWatchAlarmTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    ComparisonOperator: [, import_smithy_client.expectString, `comparisonOperator`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    DatapointsToAlarm: [, import_smithy_client.expectInt32, `datapointsToAlarm`],
+    Description: [, import_smithy_client.expectString, `description`],
+    EvaluationPeriods: [, import_smithy_client.expectInt32, `evaluationPeriods`],
+    GroupId: [, import_smithy_client.expectString, `groupId`],
+    Id: [, import_smithy_client.expectString, `id`],
+    MetricName: [, import_smithy_client.expectString, `metricName`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Period: [, import_smithy_client.expectInt32, `period`],
+    Statistic: [, import_smithy_client.expectString, `statistic`],
+    Tags: [, import_smithy_client._json, `tags`],
+    TargetResourceType: [, import_smithy_client.expectString, `targetResourceType`],
+    Threshold: [, import_smithy_client.limitedParseDouble, `threshold`],
+    TreatMissingData: [, import_smithy_client.expectString, `treatMissingData`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateCloudWatchAlarmTemplateCommand");
+var de_UpdateCloudWatchAlarmTemplateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateCloudWatchAlarmTemplateGroupCommand");
+var de_UpdateEventBridgeRuleTemplateCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    EventTargets: [, (_) => de___listOfEventBridgeRuleTemplateTarget(_, context), `eventTargets`],
+    EventType: [, import_smithy_client.expectString, `eventType`],
+    GroupId: [, import_smithy_client.expectString, `groupId`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateEventBridgeRuleTemplateCommand");
+var de_UpdateEventBridgeRuleTemplateGroupCommand = /* @__PURE__ */ __name(async (output, context) => {
+  if (output.statusCode !== 200 && output.statusCode >= 300) {
+    return de_CommandError(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 (0, import_core2.parseJsonBody)(output.body, context)), "body");
+  const doc = (0, import_smithy_client.take)(data, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+  Object.assign(contents, doc);
+  return contents;
+}, "de_UpdateEventBridgeRuleTemplateGroupCommand");
 var de_UpdateInputCommand = /* @__PURE__ */ __name(async (output, context) => {
   if (output.statusCode !== 200 && output.statusCode >= 300) {
     return de_CommandError(output, context);
@@ -3553,6 +4630,11 @@ var se___listOfColorCorrection = /* @__PURE__ */ __name((input, context) => {
     return se_ColorCorrection(entry, context);
   });
 }, "se___listOfColorCorrection");
+var se___listOfEventBridgeRuleTemplateTarget = /* @__PURE__ */ __name((input, context) => {
+  return input.filter((e) => e != null).map((entry) => {
+    return se_EventBridgeRuleTemplateTarget(entry, context);
+  });
+}, "se___listOfEventBridgeRuleTemplateTarget");
 var se___listOfFailoverCondition = /* @__PURE__ */ __name((input, context) => {
   return input.filter((e) => e != null).map((entry) => {
     return se_FailoverCondition(entry, context);
@@ -4112,6 +5194,11 @@ var se_Esam = /* @__PURE__ */ __name((input, context) => {
     zoneIdentity: [, , `ZoneIdentity`]
   });
 }, "se_Esam");
+var se_EventBridgeRuleTemplateTarget = /* @__PURE__ */ __name((input, context) => {
+  return (0, import_smithy_client.take)(input, {
+    arn: [, , `Arn`]
+  });
+}, "se_EventBridgeRuleTemplateTarget");
 var se_FailoverCondition = /* @__PURE__ */ __name((input, context) => {
   return (0, import_smithy_client.take)(input, {
     failoverConditionSettings: [, (_) => se_FailoverConditionSettings(_, context), `FailoverConditionSettings`]
@@ -5398,12 +6485,42 @@ var de___listOfChannelSummary = /* @__PURE__ */ __name((output, context) => {
   });
   return retVal;
 }, "de___listOfChannelSummary");
+var de___listOfCloudWatchAlarmTemplateGroupSummary = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CloudWatchAlarmTemplateGroupSummary(entry, context);
+  });
+  return retVal;
+}, "de___listOfCloudWatchAlarmTemplateGroupSummary");
+var de___listOfCloudWatchAlarmTemplateSummary = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_CloudWatchAlarmTemplateSummary(entry, context);
+  });
+  return retVal;
+}, "de___listOfCloudWatchAlarmTemplateSummary");
 var de___listOfColorCorrection = /* @__PURE__ */ __name((output, context) => {
   const retVal = (output || []).filter((e) => e != null).map((entry) => {
     return de_ColorCorrection(entry, context);
   });
   return retVal;
 }, "de___listOfColorCorrection");
+var de___listOfEventBridgeRuleTemplateGroupSummary = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_EventBridgeRuleTemplateGroupSummary(entry, context);
+  });
+  return retVal;
+}, "de___listOfEventBridgeRuleTemplateGroupSummary");
+var de___listOfEventBridgeRuleTemplateSummary = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_EventBridgeRuleTemplateSummary(entry, context);
+  });
+  return retVal;
+}, "de___listOfEventBridgeRuleTemplateSummary");
+var de___listOfEventBridgeRuleTemplateTarget = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_EventBridgeRuleTemplateTarget(entry, context);
+  });
+  return retVal;
+}, "de___listOfEventBridgeRuleTemplateTarget");
 var de___listOfFailoverCondition = /* @__PURE__ */ __name((output, context) => {
   const retVal = (output || []).filter((e) => e != null).map((entry) => {
     return de_FailoverCondition(entry, context);
@@ -5482,6 +6599,12 @@ var de___listOfMediaPackageOutputDestinationSettings = /* @__PURE__ */ __name((o
   });
   return retVal;
 }, "de___listOfMediaPackageOutputDestinationSettings");
+var de___listOfMediaResourceNeighbor = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_MediaResourceNeighbor(entry, context);
+  });
+  return retVal;
+}, "de___listOfMediaResourceNeighbor");
 var de___listOfMultiplexOutputDestination = /* @__PURE__ */ __name((output, context) => {
   const retVal = (output || []).filter((e) => e != null).map((entry) => {
     return de_MultiplexOutputDestination(entry, context);
@@ -5566,6 +6689,12 @@ var de___listOfScte35Descriptor = /* @__PURE__ */ __name((output, context) => {
   });
   return retVal;
 }, "de___listOfScte35Descriptor");
+var de___listOfSignalMapSummary = /* @__PURE__ */ __name((output, context) => {
+  const retVal = (output || []).filter((e) => e != null).map((entry) => {
+    return de_SignalMapSummary(entry, context);
+  });
+  return retVal;
+}, "de___listOfSignalMapSummary");
 var de___listOfThumbnail = /* @__PURE__ */ __name((output, context) => {
   const retVal = (output || []).filter((e) => e != null).map((entry) => {
     return de_Thumbnail(entry, context);
@@ -5963,6 +7092,39 @@ var de_ChannelSummary = /* @__PURE__ */ __name((output, context) => {
     Vpc: [, (_) => de_VpcOutputSettingsDescription(_, context), `vpc`]
   });
 }, "de_ChannelSummary");
+var de_CloudWatchAlarmTemplateGroupSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`],
+    TemplateCount: [, import_smithy_client.expectInt32, `templateCount`]
+  });
+}, "de_CloudWatchAlarmTemplateGroupSummary");
+var de_CloudWatchAlarmTemplateSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    ComparisonOperator: [, import_smithy_client.expectString, `comparisonOperator`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    DatapointsToAlarm: [, import_smithy_client.expectInt32, `datapointsToAlarm`],
+    Description: [, import_smithy_client.expectString, `description`],
+    EvaluationPeriods: [, import_smithy_client.expectInt32, `evaluationPeriods`],
+    GroupId: [, import_smithy_client.expectString, `groupId`],
+    Id: [, import_smithy_client.expectString, `id`],
+    MetricName: [, import_smithy_client.expectString, `metricName`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Period: [, import_smithy_client.expectInt32, `period`],
+    Statistic: [, import_smithy_client.expectString, `statistic`],
+    Tags: [, import_smithy_client._json, `tags`],
+    TargetResourceType: [, import_smithy_client.expectString, `targetResourceType`],
+    Threshold: [, import_smithy_client.limitedParseDouble, `threshold`],
+    TreatMissingData: [, import_smithy_client.expectString, `treatMissingData`]
+  });
+}, "de_CloudWatchAlarmTemplateSummary");
 var de_CmafIngestGroupSettings = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     Destination: [, (_) => de_OutputLocationRef(_, context), `destination`],
@@ -6126,6 +7288,46 @@ var de_Esam = /* @__PURE__ */ __name((output, context) => {
     ZoneIdentity: [, import_smithy_client.expectString, `zoneIdentity`]
   });
 }, "de_Esam");
+var de_EventBridgeRuleTemplateGroupSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`],
+    TemplateCount: [, import_smithy_client.expectInt32, `templateCount`]
+  });
+}, "de_EventBridgeRuleTemplateGroupSummary");
+var de_EventBridgeRuleTemplateSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    EventTargetCount: [, import_smithy_client.expectInt32, `eventTargetCount`],
+    EventType: [, import_smithy_client.expectString, `eventType`],
+    GroupId: [, import_smithy_client.expectString, `groupId`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+}, "de_EventBridgeRuleTemplateSummary");
+var de_EventBridgeRuleTemplateTarget = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: [, import_smithy_client.expectString, `arn`]
+  });
+}, "de_EventBridgeRuleTemplateTarget");
+var de_FailedMediaResourceMap = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_MediaResource(value, context);
+    return acc;
+  }, {});
+}, "de_FailedMediaResourceMap");
 var de_FailoverCondition = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     FailoverConditionSettings: [, (_) => de_FailoverConditionSettings(_, context), `failoverConditionSettings`]
@@ -6778,6 +7980,35 @@ var de_MediaPackageOutputDestinationSettings = /* @__PURE__ */ __name((output, c
     ChannelId: [, import_smithy_client.expectString, `channelId`]
   });
 }, "de_MediaPackageOutputDestinationSettings");
+var de_MediaResource = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Destinations: [, (_) => de___listOfMediaResourceNeighbor(_, context), `destinations`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Sources: [, (_) => de___listOfMediaResourceNeighbor(_, context), `sources`]
+  });
+}, "de_MediaResource");
+var de_MediaResourceMap = /* @__PURE__ */ __name((output, context) => {
+  return Object.entries(output).reduce((acc, [key, value]) => {
+    if (value === null) {
+      return acc;
+    }
+    acc[key] = de_MediaResource(value, context);
+    return acc;
+  }, {});
+}, "de_MediaResourceMap");
+var de_MediaResourceNeighbor = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    Name: [, import_smithy_client.expectString, `name`]
+  });
+}, "de_MediaResourceNeighbor");
+var de_MonitorDeployment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DetailsUri: [, import_smithy_client.expectString, `detailsUri`],
+    ErrorMessage: [, import_smithy_client.expectString, `errorMessage`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+}, "de_MonitorDeployment");
 var de_MotionGraphicsActivateScheduleActionSettings = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     Duration: [, import_smithy_client.expectLong, `duration`],
@@ -7367,6 +8598,19 @@ var de_Scte35TimeSignalScheduleActionSettings = /* @__PURE__ */ __name((output,
     Scte35Descriptors: [, (_) => de___listOfScte35Descriptor(_, context), `scte35Descriptors`]
   });
 }, "de_Scte35TimeSignalScheduleActionSettings");
+var de_SignalMapSummary = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    Arn: [, import_smithy_client.expectString, `arn`],
+    CreatedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `createdAt`],
+    Description: [, import_smithy_client.expectString, `description`],
+    Id: [, import_smithy_client.expectString, `id`],
+    ModifiedAt: [, (_) => (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(_)), `modifiedAt`],
+    MonitorDeploymentStatus: [, import_smithy_client.expectString, `monitorDeploymentStatus`],
+    Name: [, import_smithy_client.expectString, `name`],
+    Status: [, import_smithy_client.expectString, `status`],
+    Tags: [, import_smithy_client._json, `tags`]
+  });
+}, "de_SignalMapSummary");
 var de_StandardHlsSettings = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     AudioRenditionSets: [, import_smithy_client.expectString, `audioRenditionSets`],
@@ -7432,6 +8676,12 @@ var de_StopTimecode = /* @__PURE__ */ __name((output, context) => {
     Timecode: [, import_smithy_client.expectString, `timecode`]
   });
 }, "de_StopTimecode");
+var de_SuccessfulMonitorDeployment = /* @__PURE__ */ __name((output, context) => {
+  return (0, import_smithy_client.take)(output, {
+    DetailsUri: [, import_smithy_client.expectString, `detailsUri`],
+    Status: [, import_smithy_client.expectString, `status`]
+  });
+}, "de_SuccessfulMonitorDeployment");
 var de_TeletextSourceSettings = /* @__PURE__ */ __name((output, context) => {
   return (0, import_smithy_client.take)(output, {
     OutputRectangle: [, (_) => de_CaptionRectangle(_, context), `outputRectangle`],
@@ -7602,8 +8852,11 @@ var _CC = "ChannelClass";
 var _CCh = "ChannelConfiguration";
 var _CL = "ContentLength";
 var _CT = "ContentType";
+var _CWATGI = "CloudWatchAlarmTemplateGroupIdentifier";
 var _D = "Duration";
+var _EBRTGI = "EventBridgeRuleTemplateGroupIdentifier";
 var _ET = "ETag";
+var _GI = "GroupIdentifier";
 var _LM = "LastModified";
 var _MB = "MaximumBitrate";
 var _MF = "MaximumFramerate";
@@ -7612,7 +8865,9 @@ var _NT = "NextToken";
 var _PI = "PipelineId";
 var _R = "Resolution";
 var _RT = "ResourceType";
+var _S = "Scope";
 var _SF = "SpecialFeature";
+var _SMI = "SignalMapIdentifier";
 var _TK = "TagKeys";
 var _TT = "ThumbnailType";
 var _TTr = "TransferType";
@@ -7621,10 +8876,13 @@ var _a = "accept";
 var _c = "codec";
 var _cC = "channelClass";
 var _cCh = "channelConfiguration";
+var _cWATGI = "cloudWatchAlarmTemplateGroupIdentifier";
 var _cl = "content-length";
 var _ct = "content-type";
 var _d = "duration";
 var _e = "etag";
+var _eBRTGI = "eventBridgeRuleTemplateGroupIdentifier";
+var _gI = "groupIdentifier";
 var _lm = "last-modified";
 var _mB = "maximumBitrate";
 var _mF = "maximumFramerate";
@@ -7633,7 +8891,9 @@ var _nT = "nextToken";
 var _pI = "pipelineId";
 var _r = "resolution";
 var _rT = "resourceType";
+var _s = "scope";
 var _sF = "specialFeature";
+var _sMI = "signalMapIdentifier";
 var _tK = "tagKeys";
 var _tT = "thumbnailType";
 var _tTr = "transferType";
@@ -7771,6 +9031,74 @@ var _CreateChannelCommand = class _CreateChannelCommand extends import_smithy_cl
 __name(_CreateChannelCommand, "CreateChannelCommand");
 var CreateChannelCommand = _CreateChannelCommand;
 
+// src/commands/CreateCloudWatchAlarmTemplateCommand.ts
+
+
+
+
+var _CreateCloudWatchAlarmTemplateCommand = class _CreateCloudWatchAlarmTemplateCommand 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("MediaLive", "CreateCloudWatchAlarmTemplate", {}).n("MediaLiveClient", "CreateCloudWatchAlarmTemplateCommand").f(void 0, void 0).ser(se_CreateCloudWatchAlarmTemplateCommand).de(de_CreateCloudWatchAlarmTemplateCommand).build() {
+};
+__name(_CreateCloudWatchAlarmTemplateCommand, "CreateCloudWatchAlarmTemplateCommand");
+var CreateCloudWatchAlarmTemplateCommand = _CreateCloudWatchAlarmTemplateCommand;
+
+// src/commands/CreateCloudWatchAlarmTemplateGroupCommand.ts
+
+
+
+
+var _CreateCloudWatchAlarmTemplateGroupCommand = class _CreateCloudWatchAlarmTemplateGroupCommand 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("MediaLive", "CreateCloudWatchAlarmTemplateGroup", {}).n("MediaLiveClient", "CreateCloudWatchAlarmTemplateGroupCommand").f(void 0, void 0).ser(se_CreateCloudWatchAlarmTemplateGroupCommand).de(de_CreateCloudWatchAlarmTemplateGroupCommand).build() {
+};
+__name(_CreateCloudWatchAlarmTemplateGroupCommand, "CreateCloudWatchAlarmTemplateGroupCommand");
+var CreateCloudWatchAlarmTemplateGroupCommand = _CreateCloudWatchAlarmTemplateGroupCommand;
+
+// src/commands/CreateEventBridgeRuleTemplateCommand.ts
+
+
+
+
+var _CreateEventBridgeRuleTemplateCommand = class _CreateEventBridgeRuleTemplateCommand 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("MediaLive", "CreateEventBridgeRuleTemplate", {}).n("MediaLiveClient", "CreateEventBridgeRuleTemplateCommand").f(void 0, void 0).ser(se_CreateEventBridgeRuleTemplateCommand).de(de_CreateEventBridgeRuleTemplateCommand).build() {
+};
+__name(_CreateEventBridgeRuleTemplateCommand, "CreateEventBridgeRuleTemplateCommand");
+var CreateEventBridgeRuleTemplateCommand = _CreateEventBridgeRuleTemplateCommand;
+
+// src/commands/CreateEventBridgeRuleTemplateGroupCommand.ts
+
+
+
+
+var _CreateEventBridgeRuleTemplateGroupCommand = class _CreateEventBridgeRuleTemplateGroupCommand 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("MediaLive", "CreateEventBridgeRuleTemplateGroup", {}).n("MediaLiveClient", "CreateEventBridgeRuleTemplateGroupCommand").f(void 0, void 0).ser(se_CreateEventBridgeRuleTemplateGroupCommand).de(de_CreateEventBridgeRuleTemplateGroupCommand).build() {
+};
+__name(_CreateEventBridgeRuleTemplateGroupCommand, "CreateEventBridgeRuleTemplateGroupCommand");
+var CreateEventBridgeRuleTemplateGroupCommand = _CreateEventBridgeRuleTemplateGroupCommand;
+
 // src/commands/CreateInputCommand.ts
 
 
@@ -7853,42 +9181,127 @@ var _CreatePartnerInputCommand = class _CreatePartnerInputCommand extends import
   ];
 }).s("MediaLive", "CreatePartnerInput", {}).n("MediaLiveClient", "CreatePartnerInputCommand").f(void 0, void 0).ser(se_CreatePartnerInputCommand).de(de_CreatePartnerInputCommand).build() {
 };
-__name(_CreatePartnerInputCommand, "CreatePartnerInputCommand");
-var CreatePartnerInputCommand = _CreatePartnerInputCommand;
+__name(_CreatePartnerInputCommand, "CreatePartnerInputCommand");
+var CreatePartnerInputCommand = _CreatePartnerInputCommand;
+
+// src/commands/CreateSignalMapCommand.ts
+
+
+
+
+var _CreateSignalMapCommand = class _CreateSignalMapCommand 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("MediaLive", "CreateSignalMap", {}).n("MediaLiveClient", "CreateSignalMapCommand").f(void 0, void 0).ser(se_CreateSignalMapCommand).de(de_CreateSignalMapCommand).build() {
+};
+__name(_CreateSignalMapCommand, "CreateSignalMapCommand");
+var CreateSignalMapCommand = _CreateSignalMapCommand;
+
+// src/commands/CreateTagsCommand.ts
+
+
+
+
+var _CreateTagsCommand = class _CreateTagsCommand 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("MediaLive", "CreateTags", {}).n("MediaLiveClient", "CreateTagsCommand").f(void 0, void 0).ser(se_CreateTagsCommand).de(de_CreateTagsCommand).build() {
+};
+__name(_CreateTagsCommand, "CreateTagsCommand");
+var CreateTagsCommand = _CreateTagsCommand;
+
+// src/commands/DeleteChannelCommand.ts
+
+
+
+
+var _DeleteChannelCommand = class _DeleteChannelCommand 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("MediaLive", "DeleteChannel", {}).n("MediaLiveClient", "DeleteChannelCommand").f(void 0, void 0).ser(se_DeleteChannelCommand).de(de_DeleteChannelCommand).build() {
+};
+__name(_DeleteChannelCommand, "DeleteChannelCommand");
+var DeleteChannelCommand = _DeleteChannelCommand;
+
+// src/commands/DeleteCloudWatchAlarmTemplateCommand.ts
+
+
+
+
+var _DeleteCloudWatchAlarmTemplateCommand = class _DeleteCloudWatchAlarmTemplateCommand 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("MediaLive", "DeleteCloudWatchAlarmTemplate", {}).n("MediaLiveClient", "DeleteCloudWatchAlarmTemplateCommand").f(void 0, void 0).ser(se_DeleteCloudWatchAlarmTemplateCommand).de(de_DeleteCloudWatchAlarmTemplateCommand).build() {
+};
+__name(_DeleteCloudWatchAlarmTemplateCommand, "DeleteCloudWatchAlarmTemplateCommand");
+var DeleteCloudWatchAlarmTemplateCommand = _DeleteCloudWatchAlarmTemplateCommand;
+
+// src/commands/DeleteCloudWatchAlarmTemplateGroupCommand.ts
+
+
+
+
+var _DeleteCloudWatchAlarmTemplateGroupCommand = class _DeleteCloudWatchAlarmTemplateGroupCommand 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("MediaLive", "DeleteCloudWatchAlarmTemplateGroup", {}).n("MediaLiveClient", "DeleteCloudWatchAlarmTemplateGroupCommand").f(void 0, void 0).ser(se_DeleteCloudWatchAlarmTemplateGroupCommand).de(de_DeleteCloudWatchAlarmTemplateGroupCommand).build() {
+};
+__name(_DeleteCloudWatchAlarmTemplateGroupCommand, "DeleteCloudWatchAlarmTemplateGroupCommand");
+var DeleteCloudWatchAlarmTemplateGroupCommand = _DeleteCloudWatchAlarmTemplateGroupCommand;
 
-// src/commands/CreateTagsCommand.ts
+// src/commands/DeleteEventBridgeRuleTemplateCommand.ts
 
 
 
 
-var _CreateTagsCommand = class _CreateTagsCommand extends import_smithy_client.Command.classBuilder().ep({
+var _DeleteEventBridgeRuleTemplateCommand = class _DeleteEventBridgeRuleTemplateCommand 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("MediaLive", "CreateTags", {}).n("MediaLiveClient", "CreateTagsCommand").f(void 0, void 0).ser(se_CreateTagsCommand).de(de_CreateTagsCommand).build() {
+}).s("MediaLive", "DeleteEventBridgeRuleTemplate", {}).n("MediaLiveClient", "DeleteEventBridgeRuleTemplateCommand").f(void 0, void 0).ser(se_DeleteEventBridgeRuleTemplateCommand).de(de_DeleteEventBridgeRuleTemplateCommand).build() {
 };
-__name(_CreateTagsCommand, "CreateTagsCommand");
-var CreateTagsCommand = _CreateTagsCommand;
+__name(_DeleteEventBridgeRuleTemplateCommand, "DeleteEventBridgeRuleTemplateCommand");
+var DeleteEventBridgeRuleTemplateCommand = _DeleteEventBridgeRuleTemplateCommand;
 
-// src/commands/DeleteChannelCommand.ts
+// src/commands/DeleteEventBridgeRuleTemplateGroupCommand.ts
 
 
 
 
-var _DeleteChannelCommand = class _DeleteChannelCommand extends import_smithy_client.Command.classBuilder().ep({
+var _DeleteEventBridgeRuleTemplateGroupCommand = class _DeleteEventBridgeRuleTemplateGroupCommand 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("MediaLive", "DeleteChannel", {}).n("MediaLiveClient", "DeleteChannelCommand").f(void 0, void 0).ser(se_DeleteChannelCommand).de(de_DeleteChannelCommand).build() {
+}).s("MediaLive", "DeleteEventBridgeRuleTemplateGroup", {}).n("MediaLiveClient", "DeleteEventBridgeRuleTemplateGroupCommand").f(void 0, void 0).ser(se_DeleteEventBridgeRuleTemplateGroupCommand).de(de_DeleteEventBridgeRuleTemplateGroupCommand).build() {
 };
-__name(_DeleteChannelCommand, "DeleteChannelCommand");
-var DeleteChannelCommand = _DeleteChannelCommand;
+__name(_DeleteEventBridgeRuleTemplateGroupCommand, "DeleteEventBridgeRuleTemplateGroupCommand");
+var DeleteEventBridgeRuleTemplateGroupCommand = _DeleteEventBridgeRuleTemplateGroupCommand;
 
 // src/commands/DeleteInputCommand.ts
 
@@ -7992,6 +9405,23 @@ var _DeleteScheduleCommand = class _DeleteScheduleCommand extends import_smithy_
 __name(_DeleteScheduleCommand, "DeleteScheduleCommand");
 var DeleteScheduleCommand = _DeleteScheduleCommand;
 
+// src/commands/DeleteSignalMapCommand.ts
+
+
+
+
+var _DeleteSignalMapCommand = class _DeleteSignalMapCommand 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("MediaLive", "DeleteSignalMap", {}).n("MediaLiveClient", "DeleteSignalMapCommand").f(void 0, void 0).ser(se_DeleteSignalMapCommand).de(de_DeleteSignalMapCommand).build() {
+};
+__name(_DeleteSignalMapCommand, "DeleteSignalMapCommand");
+var DeleteSignalMapCommand = _DeleteSignalMapCommand;
+
 // src/commands/DeleteTagsCommand.ts
 
 
@@ -8082,6 +9512,17 @@ var DescribeInputDeviceCommand = _DescribeInputDeviceCommand;
 
 
 
+
+// src/models/models_2.ts
+var RebootInputDeviceForce = {
+  NO: "NO",
+  YES: "YES"
+};
+var DescribeInputDeviceThumbnailResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
+  ...obj
+}), "DescribeInputDeviceThumbnailResponseFilterSensitiveLog");
+
+// src/commands/DescribeInputDeviceThumbnailCommand.ts
 var _DescribeInputDeviceThumbnailCommand = class _DescribeInputDeviceThumbnailCommand extends import_smithy_client.Command.classBuilder().ep({
   ...commonParams
 }).m(function(Command, cs, config, o) {
@@ -8213,6 +9654,91 @@ var _DescribeThumbnailsCommand = class _DescribeThumbnailsCommand extends import
 __name(_DescribeThumbnailsCommand, "DescribeThumbnailsCommand");
 var DescribeThumbnailsCommand = _DescribeThumbnailsCommand;
 
+// src/commands/GetCloudWatchAlarmTemplateCommand.ts
+
+
+
+
+var _GetCloudWatchAlarmTemplateCommand = class _GetCloudWatchAlarmTemplateCommand 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("MediaLive", "GetCloudWatchAlarmTemplate", {}).n("MediaLiveClient", "GetCloudWatchAlarmTemplateCommand").f(void 0, void 0).ser(se_GetCloudWatchAlarmTemplateCommand).de(de_GetCloudWatchAlarmTemplateCommand).build() {
+};
+__name(_GetCloudWatchAlarmTemplateCommand, "GetCloudWatchAlarmTemplateCommand");
+var GetCloudWatchAlarmTemplateCommand = _GetCloudWatchAlarmTemplateCommand;
+
+// src/commands/GetCloudWatchAlarmTemplateGroupCommand.ts
+
+
+
+
+var _GetCloudWatchAlarmTemplateGroupCommand = class _GetCloudWatchAlarmTemplateGroupCommand 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("MediaLive", "GetCloudWatchAlarmTemplateGroup", {}).n("MediaLiveClient", "GetCloudWatchAlarmTemplateGroupCommand").f(void 0, void 0).ser(se_GetCloudWatchAlarmTemplateGroupCommand).de(de_GetCloudWatchAlarmTemplateGroupCommand).build() {
+};
+__name(_GetCloudWatchAlarmTemplateGroupCommand, "GetCloudWatchAlarmTemplateGroupCommand");
+var GetCloudWatchAlarmTemplateGroupCommand = _GetCloudWatchAlarmTemplateGroupCommand;
+
+// src/commands/GetEventBridgeRuleTemplateCommand.ts
+
+
+
+
+var _GetEventBridgeRuleTemplateCommand = class _GetEventBridgeRuleTemplateCommand 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("MediaLive", "GetEventBridgeRuleTemplate", {}).n("MediaLiveClient", "GetEventBridgeRuleTemplateCommand").f(void 0, void 0).ser(se_GetEventBridgeRuleTemplateCommand).de(de_GetEventBridgeRuleTemplateCommand).build() {
+};
+__name(_GetEventBridgeRuleTemplateCommand, "GetEventBridgeRuleTemplateCommand");
+var GetEventBridgeRuleTemplateCommand = _GetEventBridgeRuleTemplateCommand;
+
+// src/commands/GetEventBridgeRuleTemplateGroupCommand.ts
+
+
+
+
+var _GetEventBridgeRuleTemplateGroupCommand = class _GetEventBridgeRuleTemplateGroupCommand 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("MediaLive", "GetEventBridgeRuleTemplateGroup", {}).n("MediaLiveClient", "GetEventBridgeRuleTemplateGroupCommand").f(void 0, void 0).ser(se_GetEventBridgeRuleTemplateGroupCommand).de(de_GetEventBridgeRuleTemplateGroupCommand).build() {
+};
+__name(_GetEventBridgeRuleTemplateGroupCommand, "GetEventBridgeRuleTemplateGroupCommand");
+var GetEventBridgeRuleTemplateGroupCommand = _GetEventBridgeRuleTemplateGroupCommand;
+
+// src/commands/GetSignalMapCommand.ts
+
+
+
+
+var _GetSignalMapCommand = class _GetSignalMapCommand 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("MediaLive", "GetSignalMap", {}).n("MediaLiveClient", "GetSignalMapCommand").f(void 0, void 0).ser(se_GetSignalMapCommand).de(de_GetSignalMapCommand).build() {
+};
+__name(_GetSignalMapCommand, "GetSignalMapCommand");
+var GetSignalMapCommand = _GetSignalMapCommand;
+
 // src/commands/ListChannelsCommand.ts
 
 
@@ -8230,6 +9756,74 @@ var _ListChannelsCommand = class _ListChannelsCommand extends import_smithy_clie
 __name(_ListChannelsCommand, "ListChannelsCommand");
 var ListChannelsCommand = _ListChannelsCommand;
 
+// src/commands/ListCloudWatchAlarmTemplateGroupsCommand.ts
+
+
+
+
+var _ListCloudWatchAlarmTemplateGroupsCommand = class _ListCloudWatchAlarmTemplateGroupsCommand 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("MediaLive", "ListCloudWatchAlarmTemplateGroups", {}).n("MediaLiveClient", "ListCloudWatchAlarmTemplateGroupsCommand").f(void 0, void 0).ser(se_ListCloudWatchAlarmTemplateGroupsCommand).de(de_ListCloudWatchAlarmTemplateGroupsCommand).build() {
+};
+__name(_ListCloudWatchAlarmTemplateGroupsCommand, "ListCloudWatchAlarmTemplateGroupsCommand");
+var ListCloudWatchAlarmTemplateGroupsCommand = _ListCloudWatchAlarmTemplateGroupsCommand;
+
+// src/commands/ListCloudWatchAlarmTemplatesCommand.ts
+
+
+
+
+var _ListCloudWatchAlarmTemplatesCommand = class _ListCloudWatchAlarmTemplatesCommand 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("MediaLive", "ListCloudWatchAlarmTemplates", {}).n("MediaLiveClient", "ListCloudWatchAlarmTemplatesCommand").f(void 0, void 0).ser(se_ListCloudWatchAlarmTemplatesCommand).de(de_ListCloudWatchAlarmTemplatesCommand).build() {
+};
+__name(_ListCloudWatchAlarmTemplatesCommand, "ListCloudWatchAlarmTemplatesCommand");
+var ListCloudWatchAlarmTemplatesCommand = _ListCloudWatchAlarmTemplatesCommand;
+
+// src/commands/ListEventBridgeRuleTemplateGroupsCommand.ts
+
+
+
+
+var _ListEventBridgeRuleTemplateGroupsCommand = class _ListEventBridgeRuleTemplateGroupsCommand 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("MediaLive", "ListEventBridgeRuleTemplateGroups", {}).n("MediaLiveClient", "ListEventBridgeRuleTemplateGroupsCommand").f(void 0, void 0).ser(se_ListEventBridgeRuleTemplateGroupsCommand).de(de_ListEventBridgeRuleTemplateGroupsCommand).build() {
+};
+__name(_ListEventBridgeRuleTemplateGroupsCommand, "ListEventBridgeRuleTemplateGroupsCommand");
+var ListEventBridgeRuleTemplateGroupsCommand = _ListEventBridgeRuleTemplateGroupsCommand;
+
+// src/commands/ListEventBridgeRuleTemplatesCommand.ts
+
+
+
+
+var _ListEventBridgeRuleTemplatesCommand = class _ListEventBridgeRuleTemplatesCommand 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("MediaLive", "ListEventBridgeRuleTemplates", {}).n("MediaLiveClient", "ListEventBridgeRuleTemplatesCommand").f(void 0, void 0).ser(se_ListEventBridgeRuleTemplatesCommand).de(de_ListEventBridgeRuleTemplatesCommand).build() {
+};
+__name(_ListEventBridgeRuleTemplatesCommand, "ListEventBridgeRuleTemplatesCommand");
+var ListEventBridgeRuleTemplatesCommand = _ListEventBridgeRuleTemplatesCommand;
+
 // src/commands/ListInputDevicesCommand.ts
 
 
@@ -8366,6 +9960,23 @@ var _ListReservationsCommand = class _ListReservationsCommand extends import_smi
 __name(_ListReservationsCommand, "ListReservationsCommand");
 var ListReservationsCommand = _ListReservationsCommand;
 
+// src/commands/ListSignalMapsCommand.ts
+
+
+
+
+var _ListSignalMapsCommand = class _ListSignalMapsCommand 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("MediaLive", "ListSignalMaps", {}).n("MediaLiveClient", "ListSignalMapsCommand").f(void 0, void 0).ser(se_ListSignalMapsCommand).de(de_ListSignalMapsCommand).build() {
+};
+__name(_ListSignalMapsCommand, "ListSignalMapsCommand");
+var ListSignalMapsCommand = _ListSignalMapsCommand;
+
 // src/commands/ListTagsForResourceCommand.ts
 
 
@@ -8468,6 +10079,23 @@ var _StartChannelCommand = class _StartChannelCommand extends import_smithy_clie
 __name(_StartChannelCommand, "StartChannelCommand");
 var StartChannelCommand = _StartChannelCommand;
 
+// src/commands/StartDeleteMonitorDeploymentCommand.ts
+
+
+
+
+var _StartDeleteMonitorDeploymentCommand = class _StartDeleteMonitorDeploymentCommand 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("MediaLive", "StartDeleteMonitorDeployment", {}).n("MediaLiveClient", "StartDeleteMonitorDeploymentCommand").f(void 0, void 0).ser(se_StartDeleteMonitorDeploymentCommand).de(de_StartDeleteMonitorDeploymentCommand).build() {
+};
+__name(_StartDeleteMonitorDeploymentCommand, "StartDeleteMonitorDeploymentCommand");
+var StartDeleteMonitorDeploymentCommand = _StartDeleteMonitorDeploymentCommand;
+
 // src/commands/StartInputDeviceCommand.ts
 
 
@@ -8502,6 +10130,23 @@ var _StartInputDeviceMaintenanceWindowCommand = class _StartInputDeviceMaintenan
 __name(_StartInputDeviceMaintenanceWindowCommand, "StartInputDeviceMaintenanceWindowCommand");
 var StartInputDeviceMaintenanceWindowCommand = _StartInputDeviceMaintenanceWindowCommand;
 
+// src/commands/StartMonitorDeploymentCommand.ts
+
+
+
+
+var _StartMonitorDeploymentCommand = class _StartMonitorDeploymentCommand 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("MediaLive", "StartMonitorDeployment", {}).n("MediaLiveClient", "StartMonitorDeploymentCommand").f(void 0, void 0).ser(se_StartMonitorDeploymentCommand).de(de_StartMonitorDeploymentCommand).build() {
+};
+__name(_StartMonitorDeploymentCommand, "StartMonitorDeploymentCommand");
+var StartMonitorDeploymentCommand = _StartMonitorDeploymentCommand;
+
 // src/commands/StartMultiplexCommand.ts
 
 
@@ -8519,6 +10164,23 @@ var _StartMultiplexCommand = class _StartMultiplexCommand extends import_smithy_
 __name(_StartMultiplexCommand, "StartMultiplexCommand");
 var StartMultiplexCommand = _StartMultiplexCommand;
 
+// src/commands/StartUpdateSignalMapCommand.ts
+
+
+
+
+var _StartUpdateSignalMapCommand = class _StartUpdateSignalMapCommand 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("MediaLive", "StartUpdateSignalMap", {}).n("MediaLiveClient", "StartUpdateSignalMapCommand").f(void 0, void 0).ser(se_StartUpdateSignalMapCommand).de(de_StartUpdateSignalMapCommand).build() {
+};
+__name(_StartUpdateSignalMapCommand, "StartUpdateSignalMapCommand");
+var StartUpdateSignalMapCommand = _StartUpdateSignalMapCommand;
+
 // src/commands/StopChannelCommand.ts
 
 
@@ -8536,107 +10198,175 @@ var _StopChannelCommand = class _StopChannelCommand extends import_smithy_client
 __name(_StopChannelCommand, "StopChannelCommand");
 var StopChannelCommand = _StopChannelCommand;
 
-// src/commands/StopInputDeviceCommand.ts
+// src/commands/StopInputDeviceCommand.ts
+
+
+
+
+var _StopInputDeviceCommand = class _StopInputDeviceCommand 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("MediaLive", "StopInputDevice", {}).n("MediaLiveClient", "StopInputDeviceCommand").f(void 0, void 0).ser(se_StopInputDeviceCommand).de(de_StopInputDeviceCommand).build() {
+};
+__name(_StopInputDeviceCommand, "StopInputDeviceCommand");
+var StopInputDeviceCommand = _StopInputDeviceCommand;
+
+// src/commands/StopMultiplexCommand.ts
+
+
+
+
+var _StopMultiplexCommand = class _StopMultiplexCommand 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("MediaLive", "StopMultiplex", {}).n("MediaLiveClient", "StopMultiplexCommand").f(void 0, void 0).ser(se_StopMultiplexCommand).de(de_StopMultiplexCommand).build() {
+};
+__name(_StopMultiplexCommand, "StopMultiplexCommand");
+var StopMultiplexCommand = _StopMultiplexCommand;
+
+// src/commands/TransferInputDeviceCommand.ts
+
+
+
+
+var _TransferInputDeviceCommand = class _TransferInputDeviceCommand 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("MediaLive", "TransferInputDevice", {}).n("MediaLiveClient", "TransferInputDeviceCommand").f(void 0, void 0).ser(se_TransferInputDeviceCommand).de(de_TransferInputDeviceCommand).build() {
+};
+__name(_TransferInputDeviceCommand, "TransferInputDeviceCommand");
+var TransferInputDeviceCommand = _TransferInputDeviceCommand;
+
+// src/commands/UpdateAccountConfigurationCommand.ts
+
+
+
+
+var _UpdateAccountConfigurationCommand = class _UpdateAccountConfigurationCommand 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("MediaLive", "UpdateAccountConfiguration", {}).n("MediaLiveClient", "UpdateAccountConfigurationCommand").f(void 0, void 0).ser(se_UpdateAccountConfigurationCommand).de(de_UpdateAccountConfigurationCommand).build() {
+};
+__name(_UpdateAccountConfigurationCommand, "UpdateAccountConfigurationCommand");
+var UpdateAccountConfigurationCommand = _UpdateAccountConfigurationCommand;
+
+// src/commands/UpdateChannelClassCommand.ts
 
 
 
 
-var _StopInputDeviceCommand = class _StopInputDeviceCommand extends import_smithy_client.Command.classBuilder().ep({
+var _UpdateChannelClassCommand = class _UpdateChannelClassCommand 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("MediaLive", "StopInputDevice", {}).n("MediaLiveClient", "StopInputDeviceCommand").f(void 0, void 0).ser(se_StopInputDeviceCommand).de(de_StopInputDeviceCommand).build() {
+}).s("MediaLive", "UpdateChannelClass", {}).n("MediaLiveClient", "UpdateChannelClassCommand").f(void 0, void 0).ser(se_UpdateChannelClassCommand).de(de_UpdateChannelClassCommand).build() {
 };
-__name(_StopInputDeviceCommand, "StopInputDeviceCommand");
-var StopInputDeviceCommand = _StopInputDeviceCommand;
+__name(_UpdateChannelClassCommand, "UpdateChannelClassCommand");
+var UpdateChannelClassCommand = _UpdateChannelClassCommand;
 
-// src/commands/StopMultiplexCommand.ts
+// src/commands/UpdateChannelCommand.ts
 
 
 
 
-var _StopMultiplexCommand = class _StopMultiplexCommand extends import_smithy_client.Command.classBuilder().ep({
+var _UpdateChannelCommand = class _UpdateChannelCommand 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("MediaLive", "StopMultiplex", {}).n("MediaLiveClient", "StopMultiplexCommand").f(void 0, void 0).ser(se_StopMultiplexCommand).de(de_StopMultiplexCommand).build() {
+}).s("MediaLive", "UpdateChannel", {}).n("MediaLiveClient", "UpdateChannelCommand").f(void 0, void 0).ser(se_UpdateChannelCommand).de(de_UpdateChannelCommand).build() {
 };
-__name(_StopMultiplexCommand, "StopMultiplexCommand");
-var StopMultiplexCommand = _StopMultiplexCommand;
+__name(_UpdateChannelCommand, "UpdateChannelCommand");
+var UpdateChannelCommand = _UpdateChannelCommand;
 
-// src/commands/TransferInputDeviceCommand.ts
+// src/commands/UpdateCloudWatchAlarmTemplateCommand.ts
 
 
 
 
-var _TransferInputDeviceCommand = class _TransferInputDeviceCommand extends import_smithy_client.Command.classBuilder().ep({
+var _UpdateCloudWatchAlarmTemplateCommand = class _UpdateCloudWatchAlarmTemplateCommand 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("MediaLive", "TransferInputDevice", {}).n("MediaLiveClient", "TransferInputDeviceCommand").f(void 0, void 0).ser(se_TransferInputDeviceCommand).de(de_TransferInputDeviceCommand).build() {
+}).s("MediaLive", "UpdateCloudWatchAlarmTemplate", {}).n("MediaLiveClient", "UpdateCloudWatchAlarmTemplateCommand").f(void 0, void 0).ser(se_UpdateCloudWatchAlarmTemplateCommand).de(de_UpdateCloudWatchAlarmTemplateCommand).build() {
 };
-__name(_TransferInputDeviceCommand, "TransferInputDeviceCommand");
-var TransferInputDeviceCommand = _TransferInputDeviceCommand;
+__name(_UpdateCloudWatchAlarmTemplateCommand, "UpdateCloudWatchAlarmTemplateCommand");
+var UpdateCloudWatchAlarmTemplateCommand = _UpdateCloudWatchAlarmTemplateCommand;
 
-// src/commands/UpdateAccountConfigurationCommand.ts
+// src/commands/UpdateCloudWatchAlarmTemplateGroupCommand.ts
 
 
 
 
-var _UpdateAccountConfigurationCommand = class _UpdateAccountConfigurationCommand extends import_smithy_client.Command.classBuilder().ep({
+var _UpdateCloudWatchAlarmTemplateGroupCommand = class _UpdateCloudWatchAlarmTemplateGroupCommand 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("MediaLive", "UpdateAccountConfiguration", {}).n("MediaLiveClient", "UpdateAccountConfigurationCommand").f(void 0, void 0).ser(se_UpdateAccountConfigurationCommand).de(de_UpdateAccountConfigurationCommand).build() {
+}).s("MediaLive", "UpdateCloudWatchAlarmTemplateGroup", {}).n("MediaLiveClient", "UpdateCloudWatchAlarmTemplateGroupCommand").f(void 0, void 0).ser(se_UpdateCloudWatchAlarmTemplateGroupCommand).de(de_UpdateCloudWatchAlarmTemplateGroupCommand).build() {
 };
-__name(_UpdateAccountConfigurationCommand, "UpdateAccountConfigurationCommand");
-var UpdateAccountConfigurationCommand = _UpdateAccountConfigurationCommand;
+__name(_UpdateCloudWatchAlarmTemplateGroupCommand, "UpdateCloudWatchAlarmTemplateGroupCommand");
+var UpdateCloudWatchAlarmTemplateGroupCommand = _UpdateCloudWatchAlarmTemplateGroupCommand;
 
-// src/commands/UpdateChannelClassCommand.ts
+// src/commands/UpdateEventBridgeRuleTemplateCommand.ts
 
 
 
 
-var _UpdateChannelClassCommand = class _UpdateChannelClassCommand extends import_smithy_client.Command.classBuilder().ep({
+var _UpdateEventBridgeRuleTemplateCommand = class _UpdateEventBridgeRuleTemplateCommand 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("MediaLive", "UpdateChannelClass", {}).n("MediaLiveClient", "UpdateChannelClassCommand").f(void 0, void 0).ser(se_UpdateChannelClassCommand).de(de_UpdateChannelClassCommand).build() {
+}).s("MediaLive", "UpdateEventBridgeRuleTemplate", {}).n("MediaLiveClient", "UpdateEventBridgeRuleTemplateCommand").f(void 0, void 0).ser(se_UpdateEventBridgeRuleTemplateCommand).de(de_UpdateEventBridgeRuleTemplateCommand).build() {
 };
-__name(_UpdateChannelClassCommand, "UpdateChannelClassCommand");
-var UpdateChannelClassCommand = _UpdateChannelClassCommand;
+__name(_UpdateEventBridgeRuleTemplateCommand, "UpdateEventBridgeRuleTemplateCommand");
+var UpdateEventBridgeRuleTemplateCommand = _UpdateEventBridgeRuleTemplateCommand;
 
-// src/commands/UpdateChannelCommand.ts
+// src/commands/UpdateEventBridgeRuleTemplateGroupCommand.ts
 
 
 
 
-var _UpdateChannelCommand = class _UpdateChannelCommand extends import_smithy_client.Command.classBuilder().ep({
+var _UpdateEventBridgeRuleTemplateGroupCommand = class _UpdateEventBridgeRuleTemplateGroupCommand 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("MediaLive", "UpdateChannel", {}).n("MediaLiveClient", "UpdateChannelCommand").f(void 0, void 0).ser(se_UpdateChannelCommand).de(de_UpdateChannelCommand).build() {
+}).s("MediaLive", "UpdateEventBridgeRuleTemplateGroup", {}).n("MediaLiveClient", "UpdateEventBridgeRuleTemplateGroupCommand").f(void 0, void 0).ser(se_UpdateEventBridgeRuleTemplateGroupCommand).de(de_UpdateEventBridgeRuleTemplateGroupCommand).build() {
 };
-__name(_UpdateChannelCommand, "UpdateChannelCommand");
-var UpdateChannelCommand = _UpdateChannelCommand;
+__name(_UpdateEventBridgeRuleTemplateGroupCommand, "UpdateEventBridgeRuleTemplateGroupCommand");
+var UpdateEventBridgeRuleTemplateGroupCommand = _UpdateEventBridgeRuleTemplateGroupCommand;
 
 // src/commands/UpdateInputCommand.ts
 
@@ -8750,19 +10480,29 @@ var commands = {
   CancelInputDeviceTransferCommand,
   ClaimDeviceCommand,
   CreateChannelCommand,
+  CreateCloudWatchAlarmTemplateCommand,
+  CreateCloudWatchAlarmTemplateGroupCommand,
+  CreateEventBridgeRuleTemplateCommand,
+  CreateEventBridgeRuleTemplateGroupCommand,
   CreateInputCommand,
   CreateInputSecurityGroupCommand,
   CreateMultiplexCommand,
   CreateMultiplexProgramCommand,
   CreatePartnerInputCommand,
+  CreateSignalMapCommand,
   CreateTagsCommand,
   DeleteChannelCommand,
+  DeleteCloudWatchAlarmTemplateCommand,
+  DeleteCloudWatchAlarmTemplateGroupCommand,
+  DeleteEventBridgeRuleTemplateCommand,
+  DeleteEventBridgeRuleTemplateGroupCommand,
   DeleteInputCommand,
   DeleteInputSecurityGroupCommand,
   DeleteMultiplexCommand,
   DeleteMultiplexProgramCommand,
   DeleteReservationCommand,
   DeleteScheduleCommand,
+  DeleteSignalMapCommand,
   DeleteTagsCommand,
   DescribeAccountConfigurationCommand,
   DescribeChannelCommand,
@@ -8776,7 +10516,16 @@ var commands = {
   DescribeReservationCommand,
   DescribeScheduleCommand,
   DescribeThumbnailsCommand,
+  GetCloudWatchAlarmTemplateCommand,
+  GetCloudWatchAlarmTemplateGroupCommand,
+  GetEventBridgeRuleTemplateCommand,
+  GetEventBridgeRuleTemplateGroupCommand,
+  GetSignalMapCommand,
   ListChannelsCommand,
+  ListCloudWatchAlarmTemplateGroupsCommand,
+  ListCloudWatchAlarmTemplatesCommand,
+  ListEventBridgeRuleTemplateGroupsCommand,
+  ListEventBridgeRuleTemplatesCommand,
   ListInputDevicesCommand,
   ListInputDeviceTransfersCommand,
   ListInputsCommand,
@@ -8785,15 +10534,19 @@ var commands = {
   ListMultiplexProgramsCommand,
   ListOfferingsCommand,
   ListReservationsCommand,
+  ListSignalMapsCommand,
   ListTagsForResourceCommand,
   PurchaseOfferingCommand,
   RebootInputDeviceCommand,
   RejectInputDeviceTransferCommand,
   RestartChannelPipelinesCommand,
   StartChannelCommand,
+  StartDeleteMonitorDeploymentCommand,
   StartInputDeviceCommand,
   StartInputDeviceMaintenanceWindowCommand,
+  StartMonitorDeploymentCommand,
   StartMultiplexCommand,
+  StartUpdateSignalMapCommand,
   StopChannelCommand,
   StopInputDeviceCommand,
   StopMultiplexCommand,
@@ -8801,6 +10554,10 @@ var commands = {
   UpdateAccountConfigurationCommand,
   UpdateChannelCommand,
   UpdateChannelClassCommand,
+  UpdateCloudWatchAlarmTemplateCommand,
+  UpdateCloudWatchAlarmTemplateGroupCommand,
+  UpdateEventBridgeRuleTemplateCommand,
+  UpdateEventBridgeRuleTemplateGroupCommand,
   UpdateInputCommand,
   UpdateInputDeviceCommand,
   UpdateInputSecurityGroupCommand,
@@ -8822,6 +10579,22 @@ var paginateDescribeSchedule = (0, import_core.createPaginator)(MediaLiveClient,
 
 var paginateListChannels = (0, import_core.createPaginator)(MediaLiveClient, ListChannelsCommand, "NextToken", "NextToken", "MaxResults");
 
+// src/pagination/ListCloudWatchAlarmTemplateGroupsPaginator.ts
+
+var paginateListCloudWatchAlarmTemplateGroups = (0, import_core.createPaginator)(MediaLiveClient, ListCloudWatchAlarmTemplateGroupsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListCloudWatchAlarmTemplatesPaginator.ts
+
+var paginateListCloudWatchAlarmTemplates = (0, import_core.createPaginator)(MediaLiveClient, ListCloudWatchAlarmTemplatesCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListEventBridgeRuleTemplateGroupsPaginator.ts
+
+var paginateListEventBridgeRuleTemplateGroups = (0, import_core.createPaginator)(MediaLiveClient, ListEventBridgeRuleTemplateGroupsCommand, "NextToken", "NextToken", "MaxResults");
+
+// src/pagination/ListEventBridgeRuleTemplatesPaginator.ts
+
+var paginateListEventBridgeRuleTemplates = (0, import_core.createPaginator)(MediaLiveClient, ListEventBridgeRuleTemplatesCommand, "NextToken", "NextToken", "MaxResults");
+
 // src/pagination/ListInputDeviceTransfersPaginator.ts
 
 var paginateListInputDeviceTransfers = (0, import_core.createPaginator)(MediaLiveClient, ListInputDeviceTransfersCommand, "NextToken", "NextToken", "MaxResults");
@@ -8854,6 +10627,10 @@ var paginateListOfferings = (0, import_core.createPaginator)(MediaLiveClient, Li
 
 var paginateListReservations = (0, import_core.createPaginator)(MediaLiveClient, ListReservationsCommand, "NextToken", "NextToken", "MaxResults");
 
+// src/pagination/ListSignalMapsPaginator.ts
+
+var paginateListSignalMaps = (0, import_core.createPaginator)(MediaLiveClient, ListSignalMapsCommand, "NextToken", "NextToken", "MaxResults");
+
 // src/waiters/waitForChannelCreated.ts
 var import_util_waiter = require("@smithy/util-waiter");
 var checkState = /* @__PURE__ */ __name(async (client, input) => {
@@ -9354,6 +11131,238 @@ var waitUntilMultiplexStopped = /* @__PURE__ */ __name(async (params, input) =>
   return (0, import_util_waiter.checkExceptions)(result);
 }, "waitUntilMultiplexStopped");
 
+// src/waiters/waitForSignalMapCreated.ts
+
+var checkState12 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetSignalMapCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.Status;
+      }, "returnComparator");
+      if (returnComparator() === "CREATE_COMPLETE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.Status;
+      }, "returnComparator");
+      if (returnComparator() === "CREATE_IN_PROGRESS") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.Status;
+      }, "returnComparator");
+      if (returnComparator() === "CREATE_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 waitForSignalMapCreated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState12);
+}, "waitForSignalMapCreated");
+var waitUntilSignalMapCreated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState12);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilSignalMapCreated");
+
+// src/waiters/waitForSignalMapMonitorDeleted.ts
+
+var checkState13 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetSignalMapCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.MonitorDeployment.Status;
+      }, "returnComparator");
+      if (returnComparator() === "DELETE_COMPLETE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.MonitorDeployment.Status;
+      }, "returnComparator");
+      if (returnComparator() === "DELETE_IN_PROGRESS") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.MonitorDeployment.Status;
+      }, "returnComparator");
+      if (returnComparator() === "DELETE_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 waitForSignalMapMonitorDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState13);
+}, "waitForSignalMapMonitorDeleted");
+var waitUntilSignalMapMonitorDeleted = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState13);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilSignalMapMonitorDeleted");
+
+// src/waiters/waitForSignalMapMonitorDeployed.ts
+
+var checkState14 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetSignalMapCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.MonitorDeployment.Status;
+      }, "returnComparator");
+      if (returnComparator() === "DRY_RUN_DEPLOYMENT_COMPLETE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.MonitorDeployment.Status;
+      }, "returnComparator");
+      if (returnComparator() === "DEPLOYMENT_COMPLETE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.MonitorDeployment.Status;
+      }, "returnComparator");
+      if (returnComparator() === "DRY_RUN_DEPLOYMENT_IN_PROGRESS") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.MonitorDeployment.Status;
+      }, "returnComparator");
+      if (returnComparator() === "DEPLOYMENT_IN_PROGRESS") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.MonitorDeployment.Status;
+      }, "returnComparator");
+      if (returnComparator() === "DRY_RUN_DEPLOYMENT_FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.MonitorDeployment.Status;
+      }, "returnComparator");
+      if (returnComparator() === "DEPLOYMENT_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 waitForSignalMapMonitorDeployed = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState14);
+}, "waitForSignalMapMonitorDeployed");
+var waitUntilSignalMapMonitorDeployed = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState14);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilSignalMapMonitorDeployed");
+
+// src/waiters/waitForSignalMapUpdated.ts
+
+var checkState15 = /* @__PURE__ */ __name(async (client, input) => {
+  let reason;
+  try {
+    const result = await client.send(new GetSignalMapCommand(input));
+    reason = result;
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.Status;
+      }, "returnComparator");
+      if (returnComparator() === "UPDATE_COMPLETE") {
+        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.Status;
+      }, "returnComparator");
+      if (returnComparator() === "UPDATE_IN_PROGRESS") {
+        return { state: import_util_waiter.WaiterState.RETRY, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.Status;
+      }, "returnComparator");
+      if (returnComparator() === "UPDATE_FAILED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+    try {
+      const returnComparator = /* @__PURE__ */ __name(() => {
+        return result.Status;
+      }, "returnComparator");
+      if (returnComparator() === "UPDATE_REVERTED") {
+        return { state: import_util_waiter.WaiterState.FAILURE, reason };
+      }
+    } catch (e) {
+    }
+  } catch (exception) {
+    reason = exception;
+  }
+  return { state: import_util_waiter.WaiterState.RETRY, reason };
+}, "checkState");
+var waitForSignalMapUpdated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState15);
+}, "waitForSignalMapUpdated");
+var waitUntilSignalMapUpdated = /* @__PURE__ */ __name(async (params, input) => {
+  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState15);
+  return (0, import_util_waiter.checkExceptions)(result);
+}, "waitUntilSignalMapUpdated");
+
 // src/models/models_0.ts
 var DashRoleAudio = {
   ALTERNATE: "ALTERNATE",
@@ -9835,12 +11844,56 @@ var ChannelState = {
   UPDATE_FAILED: "UPDATE_FAILED",
   UPDATING: "UPDATING"
 };
+var CloudWatchAlarmTemplateComparisonOperator = {
+  GreaterThanOrEqualToThreshold: "GreaterThanOrEqualToThreshold",
+  GreaterThanThreshold: "GreaterThanThreshold",
+  LessThanOrEqualToThreshold: "LessThanOrEqualToThreshold",
+  LessThanThreshold: "LessThanThreshold"
+};
+var CloudWatchAlarmTemplateStatistic = {
+  Average: "Average",
+  Maximum: "Maximum",
+  Minimum: "Minimum",
+  SampleCount: "SampleCount",
+  Sum: "Sum"
+};
+var CloudWatchAlarmTemplateTargetResourceType = {
+  CLOUDFRONT_DISTRIBUTION: "CLOUDFRONT_DISTRIBUTION",
+  MEDIACONNECT_FLOW: "MEDIACONNECT_FLOW",
+  MEDIALIVE_CHANNEL: "MEDIALIVE_CHANNEL",
+  MEDIALIVE_INPUT_DEVICE: "MEDIALIVE_INPUT_DEVICE",
+  MEDIALIVE_MULTIPLEX: "MEDIALIVE_MULTIPLEX",
+  MEDIAPACKAGE_CHANNEL: "MEDIAPACKAGE_CHANNEL",
+  MEDIAPACKAGE_ORIGIN_ENDPOINT: "MEDIAPACKAGE_ORIGIN_ENDPOINT",
+  S3_BUCKET: "S3_BUCKET"
+};
+var CloudWatchAlarmTemplateTreatMissingData = {
+  breaching: "breaching",
+  ignore: "ignore",
+  missing: "missing",
+  notBreaching: "notBreaching"
+};
 var ColorSpace = {
   HDR10: "HDR10",
   HLG_2020: "HLG_2020",
   REC_601: "REC_601",
   REC_709: "REC_709"
 };
+var EventBridgeRuleTemplateEventType = {
+  MEDIACONNECT_ALERT: "MEDIACONNECT_ALERT",
+  MEDIACONNECT_FLOW_STATUS_CHANGE: "MEDIACONNECT_FLOW_STATUS_CHANGE",
+  MEDIACONNECT_OUTPUT_HEALTH: "MEDIACONNECT_OUTPUT_HEALTH",
+  MEDIACONNECT_SOURCE_HEALTH: "MEDIACONNECT_SOURCE_HEALTH",
+  MEDIALIVE_CHANNEL_ALERT: "MEDIALIVE_CHANNEL_ALERT",
+  MEDIALIVE_CHANNEL_INPUT_CHANGE: "MEDIALIVE_CHANNEL_INPUT_CHANGE",
+  MEDIALIVE_CHANNEL_STATE_CHANGE: "MEDIALIVE_CHANNEL_STATE_CHANGE",
+  MEDIALIVE_MULTIPLEX_ALERT: "MEDIALIVE_MULTIPLEX_ALERT",
+  MEDIALIVE_MULTIPLEX_STATE_CHANGE: "MEDIALIVE_MULTIPLEX_STATE_CHANGE",
+  MEDIAPACKAGE_HARVEST_JOB_NOTIFICATION: "MEDIAPACKAGE_HARVEST_JOB_NOTIFICATION",
+  MEDIAPACKAGE_INPUT_NOTIFICATION: "MEDIAPACKAGE_INPUT_NOTIFICATION",
+  MEDIAPACKAGE_KEY_PROVIDER_NOTIFICATION: "MEDIAPACKAGE_KEY_PROVIDER_NOTIFICATION",
+  SIGNAL_MAP_ACTIVE_ALARM: "SIGNAL_MAP_ACTIVE_ALARM"
+};
 var HlsAdMarkers = {
   ADOBE: "ADOBE",
   ELEMENTAL: "ELEMENTAL",
@@ -10152,41 +12205,6 @@ var CmafNielsenId3Behavior = {
   NO_PASSTHROUGH: "NO_PASSTHROUGH",
   PASSTHROUGH: "PASSTHROUGH"
 };
-var Scte35Type = {
-  NONE: "NONE",
-  SCTE_35_WITHOUT_SEGMENTATION: "SCTE_35_WITHOUT_SEGMENTATION"
-};
-var CmafIngestSegmentLengthUnits = {
-  MILLISECONDS: "MILLISECONDS",
-  SECONDS: "SECONDS"
-};
-var HlsCaptionLanguageSetting = {
-  INSERT: "INSERT",
-  NONE: "NONE",
-  OMIT: "OMIT"
-};
-var HlsClientCache = {
-  DISABLED: "DISABLED",
-  ENABLED: "ENABLED"
-};
-var HlsCodecSpecification = {
-  RFC_4281: "RFC_4281",
-  RFC_6381: "RFC_6381"
-};
-var HlsDirectoryStructure = {
-  SINGLE_DIRECTORY: "SINGLE_DIRECTORY",
-  SUBDIRECTORY_PER_STREAM: "SUBDIRECTORY_PER_STREAM"
-};
-var HlsDiscontinuityTags = {
-  INSERT: "INSERT",
-  NEVER_INSERT: "NEVER_INSERT"
-};
-
-// src/models/models_2.ts
-var RebootInputDeviceForce = {
-  NO: "NO",
-  YES: "YES"
-};
 // Annotate the CommonJS export names for ESM import in node:
 
 0 && (module.exports = {
@@ -10203,19 +12221,29 @@ var RebootInputDeviceForce = {
   CancelInputDeviceTransferCommand,
   ClaimDeviceCommand,
   CreateChannelCommand,
+  CreateCloudWatchAlarmTemplateCommand,
+  CreateCloudWatchAlarmTemplateGroupCommand,
+  CreateEventBridgeRuleTemplateCommand,
+  CreateEventBridgeRuleTemplateGroupCommand,
   CreateInputCommand,
   CreateInputSecurityGroupCommand,
   CreateMultiplexCommand,
   CreateMultiplexProgramCommand,
   CreatePartnerInputCommand,
+  CreateSignalMapCommand,
   CreateTagsCommand,
   DeleteChannelCommand,
+  DeleteCloudWatchAlarmTemplateCommand,
+  DeleteCloudWatchAlarmTemplateGroupCommand,
+  DeleteEventBridgeRuleTemplateCommand,
+  DeleteEventBridgeRuleTemplateGroupCommand,
   DeleteInputCommand,
   DeleteInputSecurityGroupCommand,
   DeleteMultiplexCommand,
   DeleteMultiplexProgramCommand,
   DeleteReservationCommand,
   DeleteScheduleCommand,
+  DeleteSignalMapCommand,
   DeleteTagsCommand,
   DescribeAccountConfigurationCommand,
   DescribeChannelCommand,
@@ -10229,7 +12257,16 @@ var RebootInputDeviceForce = {
   DescribeReservationCommand,
   DescribeScheduleCommand,
   DescribeThumbnailsCommand,
+  GetCloudWatchAlarmTemplateCommand,
+  GetCloudWatchAlarmTemplateGroupCommand,
+  GetEventBridgeRuleTemplateCommand,
+  GetEventBridgeRuleTemplateGroupCommand,
+  GetSignalMapCommand,
   ListChannelsCommand,
+  ListCloudWatchAlarmTemplateGroupsCommand,
+  ListCloudWatchAlarmTemplatesCommand,
+  ListEventBridgeRuleTemplateGroupsCommand,
+  ListEventBridgeRuleTemplatesCommand,
   ListInputDeviceTransfersCommand,
   ListInputDevicesCommand,
   ListInputSecurityGroupsCommand,
@@ -10238,15 +12275,19 @@ var RebootInputDeviceForce = {
   ListMultiplexesCommand,
   ListOfferingsCommand,
   ListReservationsCommand,
+  ListSignalMapsCommand,
   ListTagsForResourceCommand,
   PurchaseOfferingCommand,
   RebootInputDeviceCommand,
   RejectInputDeviceTransferCommand,
   RestartChannelPipelinesCommand,
   StartChannelCommand,
+  StartDeleteMonitorDeploymentCommand,
   StartInputDeviceCommand,
   StartInputDeviceMaintenanceWindowCommand,
+  StartMonitorDeploymentCommand,
   StartMultiplexCommand,
+  StartUpdateSignalMapCommand,
   StopChannelCommand,
   StopInputDeviceCommand,
   StopMultiplexCommand,
@@ -10254,6 +12295,10 @@ var RebootInputDeviceForce = {
   UpdateAccountConfigurationCommand,
   UpdateChannelClassCommand,
   UpdateChannelCommand,
+  UpdateCloudWatchAlarmTemplateCommand,
+  UpdateCloudWatchAlarmTemplateGroupCommand,
+  UpdateEventBridgeRuleTemplateCommand,
+  UpdateEventBridgeRuleTemplateGroupCommand,
   UpdateInputCommand,
   UpdateInputDeviceCommand,
   UpdateInputSecurityGroupCommand,
@@ -10262,6 +12307,10 @@ var RebootInputDeviceForce = {
   UpdateReservationCommand,
   paginateDescribeSchedule,
   paginateListChannels,
+  paginateListCloudWatchAlarmTemplateGroups,
+  paginateListCloudWatchAlarmTemplates,
+  paginateListEventBridgeRuleTemplateGroups,
+  paginateListEventBridgeRuleTemplates,
   paginateListInputDeviceTransfers,
   paginateListInputDevices,
   paginateListInputSecurityGroups,
@@ -10270,6 +12319,7 @@ var RebootInputDeviceForce = {
   paginateListMultiplexes,
   paginateListOfferings,
   paginateListReservations,
+  paginateListSignalMaps,
   waitForChannelCreated,
   waitUntilChannelCreated,
   waitForChannelDeleted,
@@ -10292,6 +12342,14 @@ var RebootInputDeviceForce = {
   waitUntilMultiplexRunning,
   waitForMultiplexStopped,
   waitUntilMultiplexStopped,
+  waitForSignalMapCreated,
+  waitUntilSignalMapCreated,
+  waitForSignalMapMonitorDeleted,
+  waitUntilSignalMapMonitorDeleted,
+  waitForSignalMapMonitorDeployed,
+  waitUntilSignalMapMonitorDeployed,
+  waitForSignalMapUpdated,
+  waitUntilSignalMapUpdated,
   DashRoleAudio,
   AudioNormalizationAlgorithm,
   AudioNormalizationAlgorithmControl,
@@ -10378,7 +12436,12 @@ var RebootInputDeviceForce = {
   LogLevel,
   MaintenanceDay,
   ChannelState,
+  CloudWatchAlarmTemplateComparisonOperator,
+  CloudWatchAlarmTemplateStatistic,
+  CloudWatchAlarmTemplateTargetResourceType,
+  CloudWatchAlarmTemplateTreatMissingData,
   ColorSpace,
+  EventBridgeRuleTemplateEventType,
   HlsAdMarkers,
   InputClass,
   InputSourceType,
@@ -10500,6 +12563,8 @@ var RebootInputDeviceForce = {
   Scte35WebDeliveryAllowedFlag,
   Scte35SegmentationCancelIndicator,
   FollowPoint,
+  SignalMapMonitorDeploymentStatus,
+  SignalMapStatus,
   ThumbnailType,
   InputDeviceTransferType,
   FrameCaptureIntervalUnit,
@@ -10587,7 +12652,7 @@ var RebootInputDeviceForce = {
   TimecodeConfigSource,
   ContentType,
   PreferredChannelPipeline,
-  DescribeInputDeviceThumbnailResponseFilterSensitiveLog,
-  RebootInputDeviceForce
+  RebootInputDeviceForce,
+  DescribeInputDeviceThumbnailResponseFilterSensitiveLog
 });