"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  ActionsSuppressedBy: () => ActionsSuppressedBy,
  AlarmType: () => AlarmType,
  AnomalyDetectorStateValue: () => AnomalyDetectorStateValue,
  AnomalyDetectorType: () => AnomalyDetectorType,
  CloudWatch: () => CloudWatch,
  CloudWatchClient: () => CloudWatchClient,
  CloudWatchServiceException: () => CloudWatchServiceException,
  ComparisonOperator: () => ComparisonOperator,
  ConcurrentModificationException: () => ConcurrentModificationException,
  DashboardInvalidInputError: () => DashboardInvalidInputError,
  DashboardNotFoundError: () => DashboardNotFoundError,
  DeleteAlarmsCommand: () => DeleteAlarmsCommand,
  DeleteAnomalyDetectorCommand: () => DeleteAnomalyDetectorCommand,
  DeleteDashboardsCommand: () => DeleteDashboardsCommand,
  DeleteInsightRulesCommand: () => DeleteInsightRulesCommand,
  DeleteMetricStreamCommand: () => DeleteMetricStreamCommand,
  DescribeAlarmHistoryCommand: () => DescribeAlarmHistoryCommand,
  DescribeAlarmsCommand: () => DescribeAlarmsCommand,
  DescribeAlarmsForMetricCommand: () => DescribeAlarmsForMetricCommand,
  DescribeAnomalyDetectorsCommand: () => DescribeAnomalyDetectorsCommand,
  DescribeInsightRulesCommand: () => DescribeInsightRulesCommand,
  DisableAlarmActionsCommand: () => DisableAlarmActionsCommand,
  DisableInsightRulesCommand: () => DisableInsightRulesCommand,
  EnableAlarmActionsCommand: () => EnableAlarmActionsCommand,
  EnableInsightRulesCommand: () => EnableInsightRulesCommand,
  EvaluationState: () => EvaluationState,
  GetDashboardCommand: () => GetDashboardCommand,
  GetInsightRuleReportCommand: () => GetInsightRuleReportCommand,
  GetMetricDataCommand: () => GetMetricDataCommand,
  GetMetricStatisticsCommand: () => GetMetricStatisticsCommand,
  GetMetricStreamCommand: () => GetMetricStreamCommand,
  GetMetricWidgetImageCommand: () => GetMetricWidgetImageCommand,
  HistoryItemType: () => HistoryItemType,
  InternalServiceFault: () => InternalServiceFault,
  InvalidFormatFault: () => InvalidFormatFault,
  InvalidNextToken: () => InvalidNextToken,
  InvalidParameterCombinationException: () => InvalidParameterCombinationException,
  InvalidParameterValueException: () => InvalidParameterValueException,
  LimitExceededException: () => LimitExceededException,
  LimitExceededFault: () => LimitExceededFault,
  ListDashboardsCommand: () => ListDashboardsCommand,
  ListManagedInsightRulesCommand: () => ListManagedInsightRulesCommand,
  ListMetricStreamsCommand: () => ListMetricStreamsCommand,
  ListMetricsCommand: () => ListMetricsCommand,
  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
  MetricStreamOutputFormat: () => MetricStreamOutputFormat,
  MissingRequiredParameterException: () => MissingRequiredParameterException,
  PutAnomalyDetectorCommand: () => PutAnomalyDetectorCommand,
  PutCompositeAlarmCommand: () => PutCompositeAlarmCommand,
  PutDashboardCommand: () => PutDashboardCommand,
  PutInsightRuleCommand: () => PutInsightRuleCommand,
  PutManagedInsightRulesCommand: () => PutManagedInsightRulesCommand,
  PutMetricAlarmCommand: () => PutMetricAlarmCommand,
  PutMetricDataCommand: () => PutMetricDataCommand,
  PutMetricStreamCommand: () => PutMetricStreamCommand,
  RecentlyActive: () => RecentlyActive,
  ResourceNotFound: () => ResourceNotFound,
  ResourceNotFoundException: () => ResourceNotFoundException,
  ScanBy: () => ScanBy,
  SetAlarmStateCommand: () => SetAlarmStateCommand,
  StandardUnit: () => StandardUnit,
  StartMetricStreamsCommand: () => StartMetricStreamsCommand,
  StateValue: () => StateValue,
  Statistic: () => Statistic,
  StatusCode: () => StatusCode,
  StopMetricStreamsCommand: () => StopMetricStreamsCommand,
  TagResourceCommand: () => TagResourceCommand,
  UntagResourceCommand: () => UntagResourceCommand,
  __Client: () => import_smithy_client.Client,
  paginateDescribeAlarmHistory: () => paginateDescribeAlarmHistory,
  paginateDescribeAlarms: () => paginateDescribeAlarms,
  paginateDescribeAnomalyDetectors: () => paginateDescribeAnomalyDetectors,
  paginateDescribeInsightRules: () => paginateDescribeInsightRules,
  paginateGetMetricData: () => paginateGetMetricData,
  paginateListDashboards: () => paginateListDashboards,
  paginateListManagedInsightRules: () => paginateListManagedInsightRules,
  paginateListMetricStreams: () => paginateListMetricStreams,
  paginateListMetrics: () => paginateListMetrics,
  waitForAlarmExists: () => waitForAlarmExists,
  waitForCompositeAlarmExists: () => waitForCompositeAlarmExists,
  waitUntilAlarmExists: () => waitUntilAlarmExists,
  waitUntilCompositeAlarmExists: () => waitUntilCompositeAlarmExists
});
module.exports = __toCommonJS(src_exports);

// src/CloudWatchClient.ts
var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
var import_middleware_logger = require("@aws-sdk/middleware-logger");
var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core = require("@smithy/core");
var import_middleware_compression = require("@smithy/middleware-compression");
var import_middleware_content_length = require("@smithy/middleware-content-length");
var import_middleware_endpoint = require("@smithy/middleware-endpoint");
var import_middleware_retry = require("@smithy/middleware-retry");

var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");

// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
  return {
    ...options,
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "monitoring"
  };
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};

// src/CloudWatchClient.ts
var import_runtimeConfig = require("././runtimeConfig");

// src/runtimeExtensions.ts
var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
var import_protocol_http = require("@smithy/protocol-http");
var import_smithy_client = require("@smithy/smithy-client");

// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
  let _credentials = runtimeConfig.credentials;
  return {
    setHttpAuthScheme(httpAuthScheme) {
      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
      if (index === -1) {
        _httpAuthSchemes.push(httpAuthScheme);
      } else {
        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
      }
    },
    httpAuthSchemes() {
      return _httpAuthSchemes;
    },
    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
      _httpAuthSchemeProvider = httpAuthSchemeProvider;
    },
    httpAuthSchemeProvider() {
      return _httpAuthSchemeProvider;
    },
    setCredentials(credentials) {
      _credentials = credentials;
    },
    credentials() {
      return _credentials;
    }
  };
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
  return {
    httpAuthSchemes: config.httpAuthSchemes(),
    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
    credentials: config.credentials()
  };
}, "resolveHttpAuthRuntimeConfig");

// src/runtimeExtensions.ts
var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
  const extensionConfiguration = {
    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig)),
    ...asPartial(getHttpAuthExtensionConfiguration(runtimeConfig))
  };
  extensions.forEach((extension) => extension.configure(extensionConfiguration));
  return {
    ...runtimeConfig,
    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
  };
}, "resolveRuntimeExtensions");

// src/CloudWatchClient.ts
var _CloudWatchClient = class _CloudWatchClient extends import_smithy_client.Client {
  constructor(...[configuration]) {
    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
    const _config_1 = resolveClientEndpointParameters(_config_0);
    const _config_2 = (0, import_config_resolver.resolveRegionConfig)(_config_1);
    const _config_3 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_2);
    const _config_4 = (0, import_middleware_retry.resolveRetryConfig)(_config_3);
    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
    const _config_6 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_5);
    const _config_7 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_6);
    const _config_8 = (0, import_middleware_compression.resolveCompressionConfig)(_config_7);
    const _config_9 = resolveRuntimeExtensions(_config_8, (configuration == null ? void 0 : configuration.extensions) || []);
    super(_config_9);
    this.config = _config_9;
    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
    this.middlewareStack.use(
      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
        httpAuthSchemeParametersProvider: this.getDefaultHttpAuthSchemeParametersProvider(),
        identityProviderConfigProvider: this.getIdentityProviderConfigProvider()
      })
    );
    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
  }
  /**
   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
   */
  destroy() {
    super.destroy();
  }
  getDefaultHttpAuthSchemeParametersProvider() {
    return import_httpAuthSchemeProvider.defaultCloudWatchHttpAuthSchemeParametersProvider;
  }
  getIdentityProviderConfigProvider() {
    return async (config) => new import_core.DefaultIdentityProviderConfig({
      "aws.auth#sigv4": config.credentials
    });
  }
};
__name(_CloudWatchClient, "CloudWatchClient");
var CloudWatchClient = _CloudWatchClient;

// src/CloudWatch.ts


// src/commands/DeleteAlarmsCommand.ts

var import_middleware_serde = require("@smithy/middleware-serde");

var import_types = require("@smithy/types");

// src/protocols/Aws_query.ts


var import_fast_xml_parser = require("fast-xml-parser");

// src/models/CloudWatchServiceException.ts

var _CloudWatchServiceException = class _CloudWatchServiceException extends import_smithy_client.ServiceException {
  /**
   * @internal
   */
  constructor(options) {
    super(options);
    Object.setPrototypeOf(this, _CloudWatchServiceException.prototype);
  }
};
__name(_CloudWatchServiceException, "CloudWatchServiceException");
var CloudWatchServiceException = _CloudWatchServiceException;

// src/models/models_0.ts
var ActionsSuppressedBy = {
  Alarm: "Alarm",
  ExtensionPeriod: "ExtensionPeriod",
  WaitPeriod: "WaitPeriod"
};
var AlarmType = {
  CompositeAlarm: "CompositeAlarm",
  MetricAlarm: "MetricAlarm"
};
var HistoryItemType = {
  Action: "Action",
  ConfigurationUpdate: "ConfigurationUpdate",
  StateUpdate: "StateUpdate"
};
var StandardUnit = {
  Bits: "Bits",
  Bits_Second: "Bits/Second",
  Bytes: "Bytes",
  Bytes_Second: "Bytes/Second",
  Count: "Count",
  Count_Second: "Count/Second",
  Gigabits: "Gigabits",
  Gigabits_Second: "Gigabits/Second",
  Gigabytes: "Gigabytes",
  Gigabytes_Second: "Gigabytes/Second",
  Kilobits: "Kilobits",
  Kilobits_Second: "Kilobits/Second",
  Kilobytes: "Kilobytes",
  Kilobytes_Second: "Kilobytes/Second",
  Megabits: "Megabits",
  Megabits_Second: "Megabits/Second",
  Megabytes: "Megabytes",
  Megabytes_Second: "Megabytes/Second",
  Microseconds: "Microseconds",
  Milliseconds: "Milliseconds",
  None: "None",
  Percent: "Percent",
  Seconds: "Seconds",
  Terabits: "Terabits",
  Terabits_Second: "Terabits/Second",
  Terabytes: "Terabytes",
  Terabytes_Second: "Terabytes/Second"
};
var AnomalyDetectorStateValue = {
  PENDING_TRAINING: "PENDING_TRAINING",
  TRAINED: "TRAINED",
  TRAINED_INSUFFICIENT_DATA: "TRAINED_INSUFFICIENT_DATA"
};
var AnomalyDetectorType = {
  METRIC_MATH: "METRIC_MATH",
  SINGLE_METRIC: "SINGLE_METRIC"
};
var ComparisonOperator = {
  GreaterThanOrEqualToThreshold: "GreaterThanOrEqualToThreshold",
  GreaterThanThreshold: "GreaterThanThreshold",
  GreaterThanUpperThreshold: "GreaterThanUpperThreshold",
  LessThanLowerOrGreaterThanUpperThreshold: "LessThanLowerOrGreaterThanUpperThreshold",
  LessThanLowerThreshold: "LessThanLowerThreshold",
  LessThanOrEqualToThreshold: "LessThanOrEqualToThreshold",
  LessThanThreshold: "LessThanThreshold"
};
var StateValue = {
  ALARM: "ALARM",
  INSUFFICIENT_DATA: "INSUFFICIENT_DATA",
  OK: "OK"
};
var _ConcurrentModificationException = class _ConcurrentModificationException extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ConcurrentModificationException",
      $fault: "client",
      ...opts
    });
    this.name = "ConcurrentModificationException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ConcurrentModificationException.prototype);
    this.Message = opts.Message;
  }
};
__name(_ConcurrentModificationException, "ConcurrentModificationException");
var ConcurrentModificationException = _ConcurrentModificationException;
var _DashboardInvalidInputError = class _DashboardInvalidInputError extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "DashboardInvalidInputError",
      $fault: "client",
      ...opts
    });
    this.name = "DashboardInvalidInputError";
    this.$fault = "client";
    Object.setPrototypeOf(this, _DashboardInvalidInputError.prototype);
    this.dashboardValidationMessages = opts.dashboardValidationMessages;
  }
};
__name(_DashboardInvalidInputError, "DashboardInvalidInputError");
var DashboardInvalidInputError = _DashboardInvalidInputError;
var _DashboardNotFoundError = class _DashboardNotFoundError extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "DashboardNotFoundError",
      $fault: "client",
      ...opts
    });
    this.name = "DashboardNotFoundError";
    this.$fault = "client";
    Object.setPrototypeOf(this, _DashboardNotFoundError.prototype);
  }
};
__name(_DashboardNotFoundError, "DashboardNotFoundError");
var DashboardNotFoundError = _DashboardNotFoundError;
var _ResourceNotFound = class _ResourceNotFound extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceNotFound",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceNotFound";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceNotFound.prototype);
  }
};
__name(_ResourceNotFound, "ResourceNotFound");
var ResourceNotFound = _ResourceNotFound;
var _InternalServiceFault = class _InternalServiceFault extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InternalServiceFault",
      $fault: "server",
      ...opts
    });
    this.name = "InternalServiceFault";
    this.$fault = "server";
    Object.setPrototypeOf(this, _InternalServiceFault.prototype);
    this.Message = opts.Message;
  }
};
__name(_InternalServiceFault, "InternalServiceFault");
var InternalServiceFault = _InternalServiceFault;
var _InvalidParameterCombinationException = class _InvalidParameterCombinationException extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidParameterCombinationException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidParameterCombinationException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidParameterCombinationException.prototype);
  }
};
__name(_InvalidParameterCombinationException, "InvalidParameterCombinationException");
var InvalidParameterCombinationException = _InvalidParameterCombinationException;
var _InvalidParameterValueException = class _InvalidParameterValueException extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidParameterValueException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidParameterValueException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidParameterValueException.prototype);
  }
};
__name(_InvalidParameterValueException, "InvalidParameterValueException");
var InvalidParameterValueException = _InvalidParameterValueException;
var _MissingRequiredParameterException = class _MissingRequiredParameterException extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "MissingRequiredParameterException",
      $fault: "client",
      ...opts
    });
    this.name = "MissingRequiredParameterException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _MissingRequiredParameterException.prototype);
  }
};
__name(_MissingRequiredParameterException, "MissingRequiredParameterException");
var MissingRequiredParameterException = _MissingRequiredParameterException;
var _ResourceNotFoundException = class _ResourceNotFoundException extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
    this.ResourceType = opts.ResourceType;
    this.ResourceId = opts.ResourceId;
    this.Message = opts.Message;
  }
};
__name(_ResourceNotFoundException, "ResourceNotFoundException");
var ResourceNotFoundException = _ResourceNotFoundException;
var ScanBy = {
  TIMESTAMP_ASCENDING: "TimestampAscending",
  TIMESTAMP_DESCENDING: "TimestampDescending"
};
var _InvalidNextToken = class _InvalidNextToken extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidNextToken",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidNextToken";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidNextToken.prototype);
  }
};
__name(_InvalidNextToken, "InvalidNextToken");
var InvalidNextToken = _InvalidNextToken;
var EvaluationState = {
  PARTIAL_DATA: "PARTIAL_DATA"
};
var Statistic = {
  Average: "Average",
  Maximum: "Maximum",
  Minimum: "Minimum",
  SampleCount: "SampleCount",
  Sum: "Sum"
};
var _LimitExceededException = class _LimitExceededException extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "LimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "LimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _LimitExceededException.prototype);
    this.Message = opts.Message;
  }
};
__name(_LimitExceededException, "LimitExceededException");
var LimitExceededException = _LimitExceededException;
var StatusCode = {
  COMPLETE: "Complete",
  FORBIDDEN: "Forbidden",
  INTERNAL_ERROR: "InternalError",
  PARTIAL_DATA: "PartialData"
};
var MetricStreamOutputFormat = {
  JSON: "json",
  OPEN_TELEMETRY_0_7: "opentelemetry0.7",
  OPEN_TELEMETRY_1_0: "opentelemetry1.0"
};
var RecentlyActive = {
  PT3H: "PT3H"
};
var _LimitExceededFault = class _LimitExceededFault extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "LimitExceededFault",
      $fault: "client",
      ...opts
    });
    this.name = "LimitExceededFault";
    this.$fault = "client";
    Object.setPrototypeOf(this, _LimitExceededFault.prototype);
  }
};
__name(_LimitExceededFault, "LimitExceededFault");
var LimitExceededFault = _LimitExceededFault;
var _InvalidFormatFault = class _InvalidFormatFault extends CloudWatchServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidFormatFault",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidFormatFault";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidFormatFault.prototype);
  }
};
__name(_InvalidFormatFault, "InvalidFormatFault");
var InvalidFormatFault = _InvalidFormatFault;

// src/protocols/Aws_query.ts
var se_DeleteAlarmsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DeleteAlarmsInput(input, context),
    [_A]: _DA,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteAlarmsCommand");
var se_DeleteAnomalyDetectorCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DeleteAnomalyDetectorInput(input, context),
    [_A]: _DAD,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteAnomalyDetectorCommand");
var se_DeleteDashboardsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DeleteDashboardsInput(input, context),
    [_A]: _DD,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteDashboardsCommand");
var se_DeleteInsightRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DeleteInsightRulesInput(input, context),
    [_A]: _DIR,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteInsightRulesCommand");
var se_DeleteMetricStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DeleteMetricStreamInput(input, context),
    [_A]: _DMS,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteMetricStreamCommand");
var se_DescribeAlarmHistoryCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DescribeAlarmHistoryInput(input, context),
    [_A]: _DAH,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeAlarmHistoryCommand");
var se_DescribeAlarmsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DescribeAlarmsInput(input, context),
    [_A]: _DAe,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeAlarmsCommand");
var se_DescribeAlarmsForMetricCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DescribeAlarmsForMetricInput(input, context),
    [_A]: _DAFM,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeAlarmsForMetricCommand");
var se_DescribeAnomalyDetectorsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DescribeAnomalyDetectorsInput(input, context),
    [_A]: _DADe,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeAnomalyDetectorsCommand");
var se_DescribeInsightRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DescribeInsightRulesInput(input, context),
    [_A]: _DIRe,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeInsightRulesCommand");
var se_DisableAlarmActionsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DisableAlarmActionsInput(input, context),
    [_A]: _DAA,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DisableAlarmActionsCommand");
var se_DisableInsightRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_DisableInsightRulesInput(input, context),
    [_A]: _DIRi,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DisableInsightRulesCommand");
var se_EnableAlarmActionsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_EnableAlarmActionsInput(input, context),
    [_A]: _EAA,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_EnableAlarmActionsCommand");
var se_EnableInsightRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_EnableInsightRulesInput(input, context),
    [_A]: _EIR,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_EnableInsightRulesCommand");
var se_GetDashboardCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_GetDashboardInput(input, context),
    [_A]: _GD,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetDashboardCommand");
var se_GetInsightRuleReportCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_GetInsightRuleReportInput(input, context),
    [_A]: _GIRR,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetInsightRuleReportCommand");
var se_GetMetricDataCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_GetMetricDataInput(input, context),
    [_A]: _GMD,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetMetricDataCommand");
var se_GetMetricStatisticsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_GetMetricStatisticsInput(input, context),
    [_A]: _GMS,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetMetricStatisticsCommand");
var se_GetMetricStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_GetMetricStreamInput(input, context),
    [_A]: _GMSe,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetMetricStreamCommand");
var se_GetMetricWidgetImageCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_GetMetricWidgetImageInput(input, context),
    [_A]: _GMWI,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetMetricWidgetImageCommand");
var se_ListDashboardsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_ListDashboardsInput(input, context),
    [_A]: _LD,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListDashboardsCommand");
var se_ListManagedInsightRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_ListManagedInsightRulesInput(input, context),
    [_A]: _LMIR,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListManagedInsightRulesCommand");
var se_ListMetricsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_ListMetricsInput(input, context),
    [_A]: _LM,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListMetricsCommand");
var se_ListMetricStreamsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_ListMetricStreamsInput(input, context),
    [_A]: _LMS,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListMetricStreamsCommand");
var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_ListTagsForResourceInput(input, context),
    [_A]: _LTFR,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListTagsForResourceCommand");
var se_PutAnomalyDetectorCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_PutAnomalyDetectorInput(input, context),
    [_A]: _PAD,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutAnomalyDetectorCommand");
var se_PutCompositeAlarmCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_PutCompositeAlarmInput(input, context),
    [_A]: _PCA,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutCompositeAlarmCommand");
var se_PutDashboardCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_PutDashboardInput(input, context),
    [_A]: _PD,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutDashboardCommand");
var se_PutInsightRuleCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_PutInsightRuleInput(input, context),
    [_A]: _PIR,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutInsightRuleCommand");
var se_PutManagedInsightRulesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_PutManagedInsightRulesInput(input, context),
    [_A]: _PMIR,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutManagedInsightRulesCommand");
var se_PutMetricAlarmCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_PutMetricAlarmInput(input, context),
    [_A]: _PMA,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutMetricAlarmCommand");
var se_PutMetricDataCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_PutMetricDataInput(input, context),
    [_A]: _PMD,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutMetricDataCommand");
var se_PutMetricStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_PutMetricStreamInput(input, context),
    [_A]: _PMS,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutMetricStreamCommand");
var se_SetAlarmStateCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_SetAlarmStateInput(input, context),
    [_A]: _SAS,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_SetAlarmStateCommand");
var se_StartMetricStreamsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_StartMetricStreamsInput(input, context),
    [_A]: _SMS,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_StartMetricStreamsCommand");
var se_StopMetricStreamsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_StopMetricStreamsInput(input, context),
    [_A]: _SMSt,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_StopMetricStreamsCommand");
var se_TagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_TagResourceInput(input, context),
    [_A]: _TR,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_TagResourceCommand");
var se_UntagResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = SHARED_HEADERS;
  let body;
  body = buildFormUrlencodedString({
    ...se_UntagResourceInput(input, context),
    [_A]: _UR,
    [_V]: _
  });
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_UntagResourceCommand");
var de_DeleteAlarmsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_DeleteAlarmsCommand");
var de_DeleteAnomalyDetectorCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_DeleteAnomalyDetectorOutput(data.DeleteAnomalyDetectorResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DeleteAnomalyDetectorCommand");
var de_DeleteDashboardsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_DeleteDashboardsOutput(data.DeleteDashboardsResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DeleteDashboardsCommand");
var de_DeleteInsightRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_DeleteInsightRulesOutput(data.DeleteInsightRulesResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DeleteInsightRulesCommand");
var de_DeleteMetricStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_DeleteMetricStreamOutput(data.DeleteMetricStreamResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DeleteMetricStreamCommand");
var de_DescribeAlarmHistoryCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_DescribeAlarmHistoryOutput(data.DescribeAlarmHistoryResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeAlarmHistoryCommand");
var de_DescribeAlarmsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_DescribeAlarmsOutput(data.DescribeAlarmsResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeAlarmsCommand");
var de_DescribeAlarmsForMetricCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_DescribeAlarmsForMetricOutput(data.DescribeAlarmsForMetricResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeAlarmsForMetricCommand");
var de_DescribeAnomalyDetectorsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_DescribeAnomalyDetectorsOutput(data.DescribeAnomalyDetectorsResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeAnomalyDetectorsCommand");
var de_DescribeInsightRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_DescribeInsightRulesOutput(data.DescribeInsightRulesResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DescribeInsightRulesCommand");
var de_DisableAlarmActionsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_DisableAlarmActionsCommand");
var de_DisableInsightRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_DisableInsightRulesOutput(data.DisableInsightRulesResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_DisableInsightRulesCommand");
var de_EnableAlarmActionsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_EnableAlarmActionsCommand");
var de_EnableInsightRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_EnableInsightRulesOutput(data.EnableInsightRulesResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_EnableInsightRulesCommand");
var de_GetDashboardCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_GetDashboardOutput(data.GetDashboardResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_GetDashboardCommand");
var de_GetInsightRuleReportCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_GetInsightRuleReportOutput(data.GetInsightRuleReportResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_GetInsightRuleReportCommand");
var de_GetMetricDataCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_GetMetricDataOutput(data.GetMetricDataResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_GetMetricDataCommand");
var de_GetMetricStatisticsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_GetMetricStatisticsOutput(data.GetMetricStatisticsResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_GetMetricStatisticsCommand");
var de_GetMetricStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_GetMetricStreamOutput(data.GetMetricStreamResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_GetMetricStreamCommand");
var de_GetMetricWidgetImageCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_GetMetricWidgetImageOutput(data.GetMetricWidgetImageResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_GetMetricWidgetImageCommand");
var de_ListDashboardsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_ListDashboardsOutput(data.ListDashboardsResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListDashboardsCommand");
var de_ListManagedInsightRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_ListManagedInsightRulesOutput(data.ListManagedInsightRulesResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListManagedInsightRulesCommand");
var de_ListMetricsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_ListMetricsOutput(data.ListMetricsResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListMetricsCommand");
var de_ListMetricStreamsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_ListMetricStreamsOutput(data.ListMetricStreamsResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListMetricStreamsCommand");
var de_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_ListTagsForResourceOutput(data.ListTagsForResourceResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_ListTagsForResourceCommand");
var de_PutAnomalyDetectorCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_PutAnomalyDetectorOutput(data.PutAnomalyDetectorResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_PutAnomalyDetectorCommand");
var de_PutCompositeAlarmCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_PutCompositeAlarmCommand");
var de_PutDashboardCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_PutDashboardOutput(data.PutDashboardResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_PutDashboardCommand");
var de_PutInsightRuleCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_PutInsightRuleOutput(data.PutInsightRuleResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_PutInsightRuleCommand");
var de_PutManagedInsightRulesCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_PutManagedInsightRulesOutput(data.PutManagedInsightRulesResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_PutManagedInsightRulesCommand");
var de_PutMetricAlarmCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_PutMetricAlarmCommand");
var de_PutMetricDataCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_PutMetricDataCommand");
var de_PutMetricStreamCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_PutMetricStreamOutput(data.PutMetricStreamResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_PutMetricStreamCommand");
var de_SetAlarmStateCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  await (0, import_smithy_client.collectBody)(output.body, context);
  const response = {
    $metadata: deserializeMetadata(output)
  };
  return response;
}, "de_SetAlarmStateCommand");
var de_StartMetricStreamsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_StartMetricStreamsOutput(data.StartMetricStreamsResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_StartMetricStreamsCommand");
var de_StopMetricStreamsCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_StopMetricStreamsOutput(data.StopMetricStreamsResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_StopMetricStreamsCommand");
var de_TagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_TagResourceOutput(data.TagResourceResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_TagResourceCommand");
var de_UntagResourceCommand = /* @__PURE__ */ __name(async (output, context) => {
  if (output.statusCode >= 300) {
    return de_CommandError(output, context);
  }
  const data = await parseBody(output.body, context);
  let contents = {};
  contents = de_UntagResourceOutput(data.UntagResourceResult, context);
  const response = {
    $metadata: deserializeMetadata(output),
    ...contents
  };
  return response;
}, "de_UntagResourceCommand");
var de_CommandError = /* @__PURE__ */ __name(async (output, context) => {
  const parsedOutput = {
    ...output,
    body: await parseErrorBody(output.body, context)
  };
  const errorCode = loadQueryErrorCode(output, parsedOutput.body);
  switch (errorCode) {
    case "ResourceNotFound":
    case "com.amazonaws.cloudwatch#ResourceNotFound":
      throw await de_ResourceNotFoundRes(parsedOutput, context);
    case "InternalServiceError":
    case "com.amazonaws.cloudwatch#InternalServiceFault":
      throw await de_InternalServiceFaultRes(parsedOutput, context);
    case "InvalidParameterCombination":
    case "com.amazonaws.cloudwatch#InvalidParameterCombinationException":
      throw await de_InvalidParameterCombinationExceptionRes(parsedOutput, context);
    case "InvalidParameterValue":
    case "com.amazonaws.cloudwatch#InvalidParameterValueException":
      throw await de_InvalidParameterValueExceptionRes(parsedOutput, context);
    case "MissingParameter":
    case "com.amazonaws.cloudwatch#MissingRequiredParameterException":
      throw await de_MissingRequiredParameterExceptionRes(parsedOutput, context);
    case "ResourceNotFoundException":
    case "com.amazonaws.cloudwatch#ResourceNotFoundException":
      throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
    case "InvalidNextToken":
    case "com.amazonaws.cloudwatch#InvalidNextToken":
      throw await de_InvalidNextTokenRes(parsedOutput, context);
    case "LimitExceededException":
    case "com.amazonaws.cloudwatch#LimitExceededException":
      throw await de_LimitExceededExceptionRes(parsedOutput, context);
    case "LimitExceeded":
    case "com.amazonaws.cloudwatch#LimitExceededFault":
      throw await de_LimitExceededFaultRes(parsedOutput, context);
    case "InvalidParameterInput":
    case "com.amazonaws.cloudwatch#DashboardInvalidInputError":
      throw await de_DashboardInvalidInputErrorRes(parsedOutput, context);
    case "ConcurrentModificationException":
    case "com.amazonaws.cloudwatch#ConcurrentModificationException":
      throw await de_ConcurrentModificationExceptionRes(parsedOutput, context);
    case "InvalidFormat":
    case "com.amazonaws.cloudwatch#InvalidFormatFault":
      throw await de_InvalidFormatFaultRes(parsedOutput, context);
    default:
      const parsedBody = parsedOutput.body;
      return throwDefaultError({
        output,
        parsedBody: parsedBody.Error,
        errorCode
      });
  }
}, "de_CommandError");
var de_ConcurrentModificationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_ConcurrentModificationException(body.Error, context);
  const exception = new ConcurrentModificationException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_ConcurrentModificationExceptionRes");
var de_DashboardInvalidInputErrorRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_DashboardInvalidInputError(body.Error, context);
  const exception = new DashboardInvalidInputError({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_DashboardInvalidInputErrorRes");
var de_InternalServiceFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_InternalServiceFault(body.Error, context);
  const exception = new InternalServiceFault({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InternalServiceFaultRes");
var de_InvalidFormatFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_InvalidFormatFault(body.Error, context);
  const exception = new InvalidFormatFault({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidFormatFaultRes");
var de_InvalidNextTokenRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_InvalidNextToken(body.Error, context);
  const exception = new InvalidNextToken({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidNextTokenRes");
var de_InvalidParameterCombinationExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_InvalidParameterCombinationException(body.Error, context);
  const exception = new InvalidParameterCombinationException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidParameterCombinationExceptionRes");
var de_InvalidParameterValueExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_InvalidParameterValueException(body.Error, context);
  const exception = new InvalidParameterValueException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_InvalidParameterValueExceptionRes");
var de_LimitExceededExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_LimitExceededException(body.Error, context);
  const exception = new LimitExceededException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_LimitExceededExceptionRes");
var de_LimitExceededFaultRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_LimitExceededFault(body.Error, context);
  const exception = new LimitExceededFault({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_LimitExceededFaultRes");
var de_MissingRequiredParameterExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_MissingRequiredParameterException(body.Error, context);
  const exception = new MissingRequiredParameterException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_MissingRequiredParameterExceptionRes");
var de_ResourceNotFoundRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_ResourceNotFound(body.Error, context);
  const exception = new ResourceNotFound({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_ResourceNotFoundRes");
var de_ResourceNotFoundExceptionRes = /* @__PURE__ */ __name(async (parsedOutput, context) => {
  const body = parsedOutput.body;
  const deserialized = de_ResourceNotFoundException(body.Error, context);
  const exception = new ResourceNotFoundException({
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized
  });
  return (0, import_smithy_client.decorateServiceException)(exception, body);
}, "de_ResourceNotFoundExceptionRes");
var se_AlarmNames = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_AlarmNames");
var se_AlarmTypes = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_AlarmTypes");
var se_AnomalyDetectorConfiguration = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_ETR] != null) {
    const memberEntries = se_AnomalyDetectorExcludedTimeRanges(input[_ETR], context);
    if (((_a = input[_ETR]) == null ? void 0 : _a.length) === 0) {
      entries.ExcludedTimeRanges = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `ExcludedTimeRanges.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_MT] != null) {
    entries[_MT] = input[_MT];
  }
  return entries;
}, "se_AnomalyDetectorConfiguration");
var se_AnomalyDetectorExcludedTimeRanges = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    const memberEntries = se_Range(entry, context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      entries[`member.${counter}.${key}`] = value;
    });
    counter++;
  }
  return entries;
}, "se_AnomalyDetectorExcludedTimeRanges");
var se_AnomalyDetectorTypes = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_AnomalyDetectorTypes");
var se_Counts = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = (0, import_smithy_client.serializeFloat)(entry);
    counter++;
  }
  return entries;
}, "se_Counts");
var se_DashboardNames = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_DashboardNames");
var se_DeleteAlarmsInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_AN] != null) {
    const memberEntries = se_AlarmNames(input[_AN], context);
    if (((_a = input[_AN]) == null ? void 0 : _a.length) === 0) {
      entries.AlarmNames = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `AlarmNames.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_DeleteAlarmsInput");
var se_DeleteAnomalyDetectorInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_MN] != null) {
    entries[_MN] = input[_MN];
  }
  if (input[_D] != null) {
    const memberEntries = se_Dimensions(input[_D], context);
    if (((_a = input[_D]) == null ? void 0 : _a.length) === 0) {
      entries.Dimensions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Dimensions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_S] != null) {
    entries[_S] = input[_S];
  }
  if (input[_SMAD] != null) {
    const memberEntries = se_SingleMetricAnomalyDetector(input[_SMAD], context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `SingleMetricAnomalyDetector.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_MMAD] != null) {
    const memberEntries = se_MetricMathAnomalyDetector(input[_MMAD], context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `MetricMathAnomalyDetector.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_DeleteAnomalyDetectorInput");
var se_DeleteDashboardsInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_DN] != null) {
    const memberEntries = se_DashboardNames(input[_DN], context);
    if (((_a = input[_DN]) == null ? void 0 : _a.length) === 0) {
      entries.DashboardNames = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `DashboardNames.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_DeleteDashboardsInput");
var se_DeleteInsightRulesInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_RN] != null) {
    const memberEntries = se_InsightRuleNames(input[_RN], context);
    if (((_a = input[_RN]) == null ? void 0 : _a.length) === 0) {
      entries.RuleNames = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `RuleNames.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_DeleteInsightRulesInput");
var se_DeleteMetricStreamInput = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_Na] != null) {
    entries[_Na] = input[_Na];
  }
  return entries;
}, "se_DeleteMetricStreamInput");
var se_DescribeAlarmHistoryInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_ANl] != null) {
    entries[_ANl] = input[_ANl];
  }
  if (input[_AT] != null) {
    const memberEntries = se_AlarmTypes(input[_AT], context);
    if (((_a = input[_AT]) == null ? void 0 : _a.length) === 0) {
      entries.AlarmTypes = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `AlarmTypes.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_HIT] != null) {
    entries[_HIT] = input[_HIT];
  }
  if (input[_SD] != null) {
    entries[_SD] = input[_SD].toISOString().split(".")[0] + "Z";
  }
  if (input[_ED] != null) {
    entries[_ED] = input[_ED].toISOString().split(".")[0] + "Z";
  }
  if (input[_MR] != null) {
    entries[_MR] = input[_MR];
  }
  if (input[_NT] != null) {
    entries[_NT] = input[_NT];
  }
  if (input[_SB] != null) {
    entries[_SB] = input[_SB];
  }
  return entries;
}, "se_DescribeAlarmHistoryInput");
var se_DescribeAlarmsForMetricInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_MN] != null) {
    entries[_MN] = input[_MN];
  }
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_St] != null) {
    entries[_St] = input[_St];
  }
  if (input[_ES] != null) {
    entries[_ES] = input[_ES];
  }
  if (input[_D] != null) {
    const memberEntries = se_Dimensions(input[_D], context);
    if (((_a = input[_D]) == null ? void 0 : _a.length) === 0) {
      entries.Dimensions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Dimensions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_P] != null) {
    entries[_P] = input[_P];
  }
  if (input[_U] != null) {
    entries[_U] = input[_U];
  }
  return entries;
}, "se_DescribeAlarmsForMetricInput");
var se_DescribeAlarmsInput = /* @__PURE__ */ __name((input, context) => {
  var _a, _b;
  const entries = {};
  if (input[_AN] != null) {
    const memberEntries = se_AlarmNames(input[_AN], context);
    if (((_a = input[_AN]) == null ? void 0 : _a.length) === 0) {
      entries.AlarmNames = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `AlarmNames.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_ANP] != null) {
    entries[_ANP] = input[_ANP];
  }
  if (input[_AT] != null) {
    const memberEntries = se_AlarmTypes(input[_AT], context);
    if (((_b = input[_AT]) == null ? void 0 : _b.length) === 0) {
      entries.AlarmTypes = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `AlarmTypes.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_COAN] != null) {
    entries[_COAN] = input[_COAN];
  }
  if (input[_POAN] != null) {
    entries[_POAN] = input[_POAN];
  }
  if (input[_SV] != null) {
    entries[_SV] = input[_SV];
  }
  if (input[_AP] != null) {
    entries[_AP] = input[_AP];
  }
  if (input[_MR] != null) {
    entries[_MR] = input[_MR];
  }
  if (input[_NT] != null) {
    entries[_NT] = input[_NT];
  }
  return entries;
}, "se_DescribeAlarmsInput");
var se_DescribeAnomalyDetectorsInput = /* @__PURE__ */ __name((input, context) => {
  var _a, _b;
  const entries = {};
  if (input[_NT] != null) {
    entries[_NT] = input[_NT];
  }
  if (input[_MRa] != null) {
    entries[_MRa] = input[_MRa];
  }
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_MN] != null) {
    entries[_MN] = input[_MN];
  }
  if (input[_D] != null) {
    const memberEntries = se_Dimensions(input[_D], context);
    if (((_a = input[_D]) == null ? void 0 : _a.length) === 0) {
      entries.Dimensions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Dimensions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_ADT] != null) {
    const memberEntries = se_AnomalyDetectorTypes(input[_ADT], context);
    if (((_b = input[_ADT]) == null ? void 0 : _b.length) === 0) {
      entries.AnomalyDetectorTypes = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `AnomalyDetectorTypes.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_DescribeAnomalyDetectorsInput");
var se_DescribeInsightRulesInput = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_NT] != null) {
    entries[_NT] = input[_NT];
  }
  if (input[_MRa] != null) {
    entries[_MRa] = input[_MRa];
  }
  return entries;
}, "se_DescribeInsightRulesInput");
var se_Dimension = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_Na] != null) {
    entries[_Na] = input[_Na];
  }
  if (input[_Va] != null) {
    entries[_Va] = input[_Va];
  }
  return entries;
}, "se_Dimension");
var se_DimensionFilter = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_Na] != null) {
    entries[_Na] = input[_Na];
  }
  if (input[_Va] != null) {
    entries[_Va] = input[_Va];
  }
  return entries;
}, "se_DimensionFilter");
var se_DimensionFilters = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    const memberEntries = se_DimensionFilter(entry, context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      entries[`member.${counter}.${key}`] = value;
    });
    counter++;
  }
  return entries;
}, "se_DimensionFilters");
var se_Dimensions = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    const memberEntries = se_Dimension(entry, context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      entries[`member.${counter}.${key}`] = value;
    });
    counter++;
  }
  return entries;
}, "se_Dimensions");
var se_DisableAlarmActionsInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_AN] != null) {
    const memberEntries = se_AlarmNames(input[_AN], context);
    if (((_a = input[_AN]) == null ? void 0 : _a.length) === 0) {
      entries.AlarmNames = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `AlarmNames.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_DisableAlarmActionsInput");
var se_DisableInsightRulesInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_RN] != null) {
    const memberEntries = se_InsightRuleNames(input[_RN], context);
    if (((_a = input[_RN]) == null ? void 0 : _a.length) === 0) {
      entries.RuleNames = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `RuleNames.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_DisableInsightRulesInput");
var se_EnableAlarmActionsInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_AN] != null) {
    const memberEntries = se_AlarmNames(input[_AN], context);
    if (((_a = input[_AN]) == null ? void 0 : _a.length) === 0) {
      entries.AlarmNames = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `AlarmNames.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_EnableAlarmActionsInput");
var se_EnableInsightRulesInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_RN] != null) {
    const memberEntries = se_InsightRuleNames(input[_RN], context);
    if (((_a = input[_RN]) == null ? void 0 : _a.length) === 0) {
      entries.RuleNames = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `RuleNames.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_EnableInsightRulesInput");
var se_ExtendedStatistics = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_ExtendedStatistics");
var se_GetDashboardInput = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_DNa] != null) {
    entries[_DNa] = input[_DNa];
  }
  return entries;
}, "se_GetDashboardInput");
var se_GetInsightRuleReportInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_RNu] != null) {
    entries[_RNu] = input[_RNu];
  }
  if (input[_ST] != null) {
    entries[_ST] = input[_ST].toISOString().split(".")[0] + "Z";
  }
  if (input[_ET] != null) {
    entries[_ET] = input[_ET].toISOString().split(".")[0] + "Z";
  }
  if (input[_P] != null) {
    entries[_P] = input[_P];
  }
  if (input[_MCC] != null) {
    entries[_MCC] = input[_MCC];
  }
  if (input[_M] != null) {
    const memberEntries = se_InsightRuleMetricList(input[_M], context);
    if (((_a = input[_M]) == null ? void 0 : _a.length) === 0) {
      entries.Metrics = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Metrics.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_OB] != null) {
    entries[_OB] = input[_OB];
  }
  return entries;
}, "se_GetInsightRuleReportInput");
var se_GetMetricDataInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_MDQ] != null) {
    const memberEntries = se_MetricDataQueries(input[_MDQ], context);
    if (((_a = input[_MDQ]) == null ? void 0 : _a.length) === 0) {
      entries.MetricDataQueries = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `MetricDataQueries.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_ST] != null) {
    entries[_ST] = input[_ST].toISOString().split(".")[0] + "Z";
  }
  if (input[_ET] != null) {
    entries[_ET] = input[_ET].toISOString().split(".")[0] + "Z";
  }
  if (input[_NT] != null) {
    entries[_NT] = input[_NT];
  }
  if (input[_SB] != null) {
    entries[_SB] = input[_SB];
  }
  if (input[_MD] != null) {
    entries[_MD] = input[_MD];
  }
  if (input[_LO] != null) {
    const memberEntries = se_LabelOptions(input[_LO], context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `LabelOptions.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_GetMetricDataInput");
var se_GetMetricStatisticsInput = /* @__PURE__ */ __name((input, context) => {
  var _a, _b, _c;
  const entries = {};
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_MN] != null) {
    entries[_MN] = input[_MN];
  }
  if (input[_D] != null) {
    const memberEntries = se_Dimensions(input[_D], context);
    if (((_a = input[_D]) == null ? void 0 : _a.length) === 0) {
      entries.Dimensions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Dimensions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_ST] != null) {
    entries[_ST] = input[_ST].toISOString().split(".")[0] + "Z";
  }
  if (input[_ET] != null) {
    entries[_ET] = input[_ET].toISOString().split(".")[0] + "Z";
  }
  if (input[_P] != null) {
    entries[_P] = input[_P];
  }
  if (input[_Sta] != null) {
    const memberEntries = se_Statistics(input[_Sta], context);
    if (((_b = input[_Sta]) == null ? void 0 : _b.length) === 0) {
      entries.Statistics = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Statistics.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_ESx] != null) {
    const memberEntries = se_ExtendedStatistics(input[_ESx], context);
    if (((_c = input[_ESx]) == null ? void 0 : _c.length) === 0) {
      entries.ExtendedStatistics = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `ExtendedStatistics.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_U] != null) {
    entries[_U] = input[_U];
  }
  return entries;
}, "se_GetMetricStatisticsInput");
var se_GetMetricStreamInput = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_Na] != null) {
    entries[_Na] = input[_Na];
  }
  return entries;
}, "se_GetMetricStreamInput");
var se_GetMetricWidgetImageInput = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_MW] != null) {
    entries[_MW] = input[_MW];
  }
  if (input[_OF] != null) {
    entries[_OF] = input[_OF];
  }
  return entries;
}, "se_GetMetricWidgetImageInput");
var se_InsightRuleMetricList = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_InsightRuleMetricList");
var se_InsightRuleNames = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_InsightRuleNames");
var se_LabelOptions = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_T] != null) {
    entries[_T] = input[_T];
  }
  return entries;
}, "se_LabelOptions");
var se_ListDashboardsInput = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_DNP] != null) {
    entries[_DNP] = input[_DNP];
  }
  if (input[_NT] != null) {
    entries[_NT] = input[_NT];
  }
  return entries;
}, "se_ListDashboardsInput");
var se_ListManagedInsightRulesInput = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_RARN] != null) {
    entries[_RARN] = input[_RARN];
  }
  if (input[_NT] != null) {
    entries[_NT] = input[_NT];
  }
  if (input[_MRa] != null) {
    entries[_MRa] = input[_MRa];
  }
  return entries;
}, "se_ListManagedInsightRulesInput");
var se_ListMetricsInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_MN] != null) {
    entries[_MN] = input[_MN];
  }
  if (input[_D] != null) {
    const memberEntries = se_DimensionFilters(input[_D], context);
    if (((_a = input[_D]) == null ? void 0 : _a.length) === 0) {
      entries.Dimensions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Dimensions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_NT] != null) {
    entries[_NT] = input[_NT];
  }
  if (input[_RA] != null) {
    entries[_RA] = input[_RA];
  }
  if (input[_ILA] != null) {
    entries[_ILA] = input[_ILA];
  }
  if (input[_OA] != null) {
    entries[_OA] = input[_OA];
  }
  return entries;
}, "se_ListMetricsInput");
var se_ListMetricStreamsInput = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_NT] != null) {
    entries[_NT] = input[_NT];
  }
  if (input[_MRa] != null) {
    entries[_MRa] = input[_MRa];
  }
  return entries;
}, "se_ListMetricStreamsInput");
var se_ListTagsForResourceInput = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_RARN] != null) {
    entries[_RARN] = input[_RARN];
  }
  return entries;
}, "se_ListTagsForResourceInput");
var se_ManagedRule = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_TN] != null) {
    entries[_TN] = input[_TN];
  }
  if (input[_RARN] != null) {
    entries[_RARN] = input[_RARN];
  }
  if (input[_Ta] != null) {
    const memberEntries = se_TagList(input[_Ta], context);
    if (((_a = input[_Ta]) == null ? void 0 : _a.length) === 0) {
      entries.Tags = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Tags.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_ManagedRule");
var se_ManagedRules = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    const memberEntries = se_ManagedRule(entry, context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      entries[`member.${counter}.${key}`] = value;
    });
    counter++;
  }
  return entries;
}, "se_ManagedRules");
var se_Metric = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_MN] != null) {
    entries[_MN] = input[_MN];
  }
  if (input[_D] != null) {
    const memberEntries = se_Dimensions(input[_D], context);
    if (((_a = input[_D]) == null ? void 0 : _a.length) === 0) {
      entries.Dimensions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Dimensions.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_Metric");
var se_MetricData = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    const memberEntries = se_MetricDatum(entry, context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      entries[`member.${counter}.${key}`] = value;
    });
    counter++;
  }
  return entries;
}, "se_MetricData");
var se_MetricDataQueries = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    const memberEntries = se_MetricDataQuery(entry, context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      entries[`member.${counter}.${key}`] = value;
    });
    counter++;
  }
  return entries;
}, "se_MetricDataQueries");
var se_MetricDataQuery = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_I] != null) {
    entries[_I] = input[_I];
  }
  if (input[_MS] != null) {
    const memberEntries = se_MetricStat(input[_MS], context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `MetricStat.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_E] != null) {
    entries[_E] = input[_E];
  }
  if (input[_L] != null) {
    entries[_L] = input[_L];
  }
  if (input[_RD] != null) {
    entries[_RD] = input[_RD];
  }
  if (input[_P] != null) {
    entries[_P] = input[_P];
  }
  if (input[_AI] != null) {
    entries[_AI] = input[_AI];
  }
  return entries;
}, "se_MetricDataQuery");
var se_MetricDatum = /* @__PURE__ */ __name((input, context) => {
  var _a, _b, _c;
  const entries = {};
  if (input[_MN] != null) {
    entries[_MN] = input[_MN];
  }
  if (input[_D] != null) {
    const memberEntries = se_Dimensions(input[_D], context);
    if (((_a = input[_D]) == null ? void 0 : _a.length) === 0) {
      entries.Dimensions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Dimensions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_Ti] != null) {
    entries[_Ti] = input[_Ti].toISOString().split(".")[0] + "Z";
  }
  if (input[_Va] != null) {
    entries[_Va] = (0, import_smithy_client.serializeFloat)(input[_Va]);
  }
  if (input[_SVt] != null) {
    const memberEntries = se_StatisticSet(input[_SVt], context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `StatisticValues.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_Val] != null) {
    const memberEntries = se_Values(input[_Val], context);
    if (((_b = input[_Val]) == null ? void 0 : _b.length) === 0) {
      entries.Values = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Values.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_C] != null) {
    const memberEntries = se_Counts(input[_C], context);
    if (((_c = input[_C]) == null ? void 0 : _c.length) === 0) {
      entries.Counts = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Counts.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_U] != null) {
    entries[_U] = input[_U];
  }
  if (input[_SR] != null) {
    entries[_SR] = input[_SR];
  }
  return entries;
}, "se_MetricDatum");
var se_MetricMathAnomalyDetector = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_MDQ] != null) {
    const memberEntries = se_MetricDataQueries(input[_MDQ], context);
    if (((_a = input[_MDQ]) == null ? void 0 : _a.length) === 0) {
      entries.MetricDataQueries = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `MetricDataQueries.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_MetricMathAnomalyDetector");
var se_MetricStat = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_Me] != null) {
    const memberEntries = se_Metric(input[_Me], context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Metric.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_P] != null) {
    entries[_P] = input[_P];
  }
  if (input[_S] != null) {
    entries[_S] = input[_S];
  }
  if (input[_U] != null) {
    entries[_U] = input[_U];
  }
  return entries;
}, "se_MetricStat");
var se_MetricStreamFilter = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_MNe] != null) {
    const memberEntries = se_MetricStreamFilterMetricNames(input[_MNe], context);
    if (((_a = input[_MNe]) == null ? void 0 : _a.length) === 0) {
      entries.MetricNames = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `MetricNames.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_MetricStreamFilter");
var se_MetricStreamFilterMetricNames = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_MetricStreamFilterMetricNames");
var se_MetricStreamFilters = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    const memberEntries = se_MetricStreamFilter(entry, context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      entries[`member.${counter}.${key}`] = value;
    });
    counter++;
  }
  return entries;
}, "se_MetricStreamFilters");
var se_MetricStreamNames = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_MetricStreamNames");
var se_MetricStreamStatisticsAdditionalStatistics = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_MetricStreamStatisticsAdditionalStatistics");
var se_MetricStreamStatisticsConfiguration = /* @__PURE__ */ __name((input, context) => {
  var _a, _b;
  const entries = {};
  if (input[_IM] != null) {
    const memberEntries = se_MetricStreamStatisticsIncludeMetrics(input[_IM], context);
    if (((_a = input[_IM]) == null ? void 0 : _a.length) === 0) {
      entries.IncludeMetrics = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `IncludeMetrics.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_AS] != null) {
    const memberEntries = se_MetricStreamStatisticsAdditionalStatistics(input[_AS], context);
    if (((_b = input[_AS]) == null ? void 0 : _b.length) === 0) {
      entries.AdditionalStatistics = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `AdditionalStatistics.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_MetricStreamStatisticsConfiguration");
var se_MetricStreamStatisticsConfigurations = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    const memberEntries = se_MetricStreamStatisticsConfiguration(entry, context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      entries[`member.${counter}.${key}`] = value;
    });
    counter++;
  }
  return entries;
}, "se_MetricStreamStatisticsConfigurations");
var se_MetricStreamStatisticsIncludeMetrics = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    const memberEntries = se_MetricStreamStatisticsMetric(entry, context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      entries[`member.${counter}.${key}`] = value;
    });
    counter++;
  }
  return entries;
}, "se_MetricStreamStatisticsIncludeMetrics");
var se_MetricStreamStatisticsMetric = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_MN] != null) {
    entries[_MN] = input[_MN];
  }
  return entries;
}, "se_MetricStreamStatisticsMetric");
var se_PutAnomalyDetectorInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_MN] != null) {
    entries[_MN] = input[_MN];
  }
  if (input[_D] != null) {
    const memberEntries = se_Dimensions(input[_D], context);
    if (((_a = input[_D]) == null ? void 0 : _a.length) === 0) {
      entries.Dimensions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Dimensions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_S] != null) {
    entries[_S] = input[_S];
  }
  if (input[_Co] != null) {
    const memberEntries = se_AnomalyDetectorConfiguration(input[_Co], context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Configuration.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_SMAD] != null) {
    const memberEntries = se_SingleMetricAnomalyDetector(input[_SMAD], context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `SingleMetricAnomalyDetector.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_MMAD] != null) {
    const memberEntries = se_MetricMathAnomalyDetector(input[_MMAD], context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `MetricMathAnomalyDetector.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_PutAnomalyDetectorInput");
var se_PutCompositeAlarmInput = /* @__PURE__ */ __name((input, context) => {
  var _a, _b, _c, _d;
  const entries = {};
  if (input[_AE] != null) {
    entries[_AE] = input[_AE];
  }
  if (input[_AA] != null) {
    const memberEntries = se_ResourceList(input[_AA], context);
    if (((_a = input[_AA]) == null ? void 0 : _a.length) === 0) {
      entries.AlarmActions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `AlarmActions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_AD] != null) {
    entries[_AD] = input[_AD];
  }
  if (input[_ANl] != null) {
    entries[_ANl] = input[_ANl];
  }
  if (input[_AR] != null) {
    entries[_AR] = input[_AR];
  }
  if (input[_IDA] != null) {
    const memberEntries = se_ResourceList(input[_IDA], context);
    if (((_b = input[_IDA]) == null ? void 0 : _b.length) === 0) {
      entries.InsufficientDataActions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `InsufficientDataActions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_OKA] != null) {
    const memberEntries = se_ResourceList(input[_OKA], context);
    if (((_c = input[_OKA]) == null ? void 0 : _c.length) === 0) {
      entries.OKActions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `OKActions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_Ta] != null) {
    const memberEntries = se_TagList(input[_Ta], context);
    if (((_d = input[_Ta]) == null ? void 0 : _d.length) === 0) {
      entries.Tags = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Tags.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_ASc] != null) {
    entries[_ASc] = input[_ASc];
  }
  if (input[_ASWP] != null) {
    entries[_ASWP] = input[_ASWP];
  }
  if (input[_ASEP] != null) {
    entries[_ASEP] = input[_ASEP];
  }
  return entries;
}, "se_PutCompositeAlarmInput");
var se_PutDashboardInput = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_DNa] != null) {
    entries[_DNa] = input[_DNa];
  }
  if (input[_DB] != null) {
    entries[_DB] = input[_DB];
  }
  return entries;
}, "se_PutDashboardInput");
var se_PutInsightRuleInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_RNu] != null) {
    entries[_RNu] = input[_RNu];
  }
  if (input[_RS] != null) {
    entries[_RS] = input[_RS];
  }
  if (input[_RDu] != null) {
    entries[_RDu] = input[_RDu];
  }
  if (input[_Ta] != null) {
    const memberEntries = se_TagList(input[_Ta], context);
    if (((_a = input[_Ta]) == null ? void 0 : _a.length) === 0) {
      entries.Tags = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Tags.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_PutInsightRuleInput");
var se_PutManagedInsightRulesInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_MRan] != null) {
    const memberEntries = se_ManagedRules(input[_MRan], context);
    if (((_a = input[_MRan]) == null ? void 0 : _a.length) === 0) {
      entries.ManagedRules = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `ManagedRules.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_PutManagedInsightRulesInput");
var se_PutMetricAlarmInput = /* @__PURE__ */ __name((input, context) => {
  var _a, _b, _c, _d, _e2, _f;
  const entries = {};
  if (input[_ANl] != null) {
    entries[_ANl] = input[_ANl];
  }
  if (input[_AD] != null) {
    entries[_AD] = input[_AD];
  }
  if (input[_AE] != null) {
    entries[_AE] = input[_AE];
  }
  if (input[_OKA] != null) {
    const memberEntries = se_ResourceList(input[_OKA], context);
    if (((_a = input[_OKA]) == null ? void 0 : _a.length) === 0) {
      entries.OKActions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `OKActions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_AA] != null) {
    const memberEntries = se_ResourceList(input[_AA], context);
    if (((_b = input[_AA]) == null ? void 0 : _b.length) === 0) {
      entries.AlarmActions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `AlarmActions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_IDA] != null) {
    const memberEntries = se_ResourceList(input[_IDA], context);
    if (((_c = input[_IDA]) == null ? void 0 : _c.length) === 0) {
      entries.InsufficientDataActions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `InsufficientDataActions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_MN] != null) {
    entries[_MN] = input[_MN];
  }
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_St] != null) {
    entries[_St] = input[_St];
  }
  if (input[_ES] != null) {
    entries[_ES] = input[_ES];
  }
  if (input[_D] != null) {
    const memberEntries = se_Dimensions(input[_D], context);
    if (((_d = input[_D]) == null ? void 0 : _d.length) === 0) {
      entries.Dimensions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Dimensions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_P] != null) {
    entries[_P] = input[_P];
  }
  if (input[_U] != null) {
    entries[_U] = input[_U];
  }
  if (input[_EP] != null) {
    entries[_EP] = input[_EP];
  }
  if (input[_DTA] != null) {
    entries[_DTA] = input[_DTA];
  }
  if (input[_Th] != null) {
    entries[_Th] = (0, import_smithy_client.serializeFloat)(input[_Th]);
  }
  if (input[_CO] != null) {
    entries[_CO] = input[_CO];
  }
  if (input[_TMD] != null) {
    entries[_TMD] = input[_TMD];
  }
  if (input[_ELSCP] != null) {
    entries[_ELSCP] = input[_ELSCP];
  }
  if (input[_M] != null) {
    const memberEntries = se_MetricDataQueries(input[_M], context);
    if (((_e2 = input[_M]) == null ? void 0 : _e2.length) === 0) {
      entries.Metrics = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Metrics.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_Ta] != null) {
    const memberEntries = se_TagList(input[_Ta], context);
    if (((_f = input[_Ta]) == null ? void 0 : _f.length) === 0) {
      entries.Tags = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Tags.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_TMI] != null) {
    entries[_TMI] = input[_TMI];
  }
  return entries;
}, "se_PutMetricAlarmInput");
var se_PutMetricDataInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_MDe] != null) {
    const memberEntries = se_MetricData(input[_MDe], context);
    if (((_a = input[_MDe]) == null ? void 0 : _a.length) === 0) {
      entries.MetricData = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `MetricData.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_PutMetricDataInput");
var se_PutMetricStreamInput = /* @__PURE__ */ __name((input, context) => {
  var _a, _b, _c, _d;
  const entries = {};
  if (input[_Na] != null) {
    entries[_Na] = input[_Na];
  }
  if (input[_IF] != null) {
    const memberEntries = se_MetricStreamFilters(input[_IF], context);
    if (((_a = input[_IF]) == null ? void 0 : _a.length) === 0) {
      entries.IncludeFilters = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `IncludeFilters.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_EF] != null) {
    const memberEntries = se_MetricStreamFilters(input[_EF], context);
    if (((_b = input[_EF]) == null ? void 0 : _b.length) === 0) {
      entries.ExcludeFilters = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `ExcludeFilters.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_FA] != null) {
    entries[_FA] = input[_FA];
  }
  if (input[_RAo] != null) {
    entries[_RAo] = input[_RAo];
  }
  if (input[_OF] != null) {
    entries[_OF] = input[_OF];
  }
  if (input[_Ta] != null) {
    const memberEntries = se_TagList(input[_Ta], context);
    if (((_c = input[_Ta]) == null ? void 0 : _c.length) === 0) {
      entries.Tags = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Tags.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_SC] != null) {
    const memberEntries = se_MetricStreamStatisticsConfigurations(input[_SC], context);
    if (((_d = input[_SC]) == null ? void 0 : _d.length) === 0) {
      entries.StatisticsConfigurations = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `StatisticsConfigurations.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_ILAM] != null) {
    entries[_ILAM] = input[_ILAM];
  }
  return entries;
}, "se_PutMetricStreamInput");
var se_Range = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_ST] != null) {
    entries[_ST] = input[_ST].toISOString().split(".")[0] + "Z";
  }
  if (input[_ET] != null) {
    entries[_ET] = input[_ET].toISOString().split(".")[0] + "Z";
  }
  return entries;
}, "se_Range");
var se_ResourceList = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_ResourceList");
var se_SetAlarmStateInput = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_ANl] != null) {
    entries[_ANl] = input[_ANl];
  }
  if (input[_SV] != null) {
    entries[_SV] = input[_SV];
  }
  if (input[_SRt] != null) {
    entries[_SRt] = input[_SRt];
  }
  if (input[_SRD] != null) {
    entries[_SRD] = input[_SRD];
  }
  return entries;
}, "se_SetAlarmStateInput");
var se_SingleMetricAnomalyDetector = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_N] != null) {
    entries[_N] = input[_N];
  }
  if (input[_MN] != null) {
    entries[_MN] = input[_MN];
  }
  if (input[_D] != null) {
    const memberEntries = se_Dimensions(input[_D], context);
    if (((_a = input[_D]) == null ? void 0 : _a.length) === 0) {
      entries.Dimensions = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Dimensions.${key}`;
      entries[loc] = value;
    });
  }
  if (input[_S] != null) {
    entries[_S] = input[_S];
  }
  return entries;
}, "se_SingleMetricAnomalyDetector");
var se_StartMetricStreamsInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_Nam] != null) {
    const memberEntries = se_MetricStreamNames(input[_Nam], context);
    if (((_a = input[_Nam]) == null ? void 0 : _a.length) === 0) {
      entries.Names = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Names.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_StartMetricStreamsInput");
var se_Statistics = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_Statistics");
var se_StatisticSet = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_SCa] != null) {
    entries[_SCa] = (0, import_smithy_client.serializeFloat)(input[_SCa]);
  }
  if (input[_Su] != null) {
    entries[_Su] = (0, import_smithy_client.serializeFloat)(input[_Su]);
  }
  if (input[_Mi] != null) {
    entries[_Mi] = (0, import_smithy_client.serializeFloat)(input[_Mi]);
  }
  if (input[_Ma] != null) {
    entries[_Ma] = (0, import_smithy_client.serializeFloat)(input[_Ma]);
  }
  return entries;
}, "se_StatisticSet");
var se_StopMetricStreamsInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_Nam] != null) {
    const memberEntries = se_MetricStreamNames(input[_Nam], context);
    if (((_a = input[_Nam]) == null ? void 0 : _a.length) === 0) {
      entries.Names = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Names.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_StopMetricStreamsInput");
var se_Tag = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  if (input[_K] != null) {
    entries[_K] = input[_K];
  }
  if (input[_Va] != null) {
    entries[_Va] = input[_Va];
  }
  return entries;
}, "se_Tag");
var se_TagKeyList = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = entry;
    counter++;
  }
  return entries;
}, "se_TagKeyList");
var se_TagList = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    const memberEntries = se_Tag(entry, context);
    Object.entries(memberEntries).forEach(([key, value]) => {
      entries[`member.${counter}.${key}`] = value;
    });
    counter++;
  }
  return entries;
}, "se_TagList");
var se_TagResourceInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_RARN] != null) {
    entries[_RARN] = input[_RARN];
  }
  if (input[_Ta] != null) {
    const memberEntries = se_TagList(input[_Ta], context);
    if (((_a = input[_Ta]) == null ? void 0 : _a.length) === 0) {
      entries.Tags = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `Tags.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_TagResourceInput");
var se_UntagResourceInput = /* @__PURE__ */ __name((input, context) => {
  var _a;
  const entries = {};
  if (input[_RARN] != null) {
    entries[_RARN] = input[_RARN];
  }
  if (input[_TK] != null) {
    const memberEntries = se_TagKeyList(input[_TK], context);
    if (((_a = input[_TK]) == null ? void 0 : _a.length) === 0) {
      entries.TagKeys = [];
    }
    Object.entries(memberEntries).forEach(([key, value]) => {
      const loc = `TagKeys.${key}`;
      entries[loc] = value;
    });
  }
  return entries;
}, "se_UntagResourceInput");
var se_Values = /* @__PURE__ */ __name((input, context) => {
  const entries = {};
  let counter = 1;
  for (const entry of input) {
    if (entry === null) {
      continue;
    }
    entries[`member.${counter}`] = (0, import_smithy_client.serializeFloat)(entry);
    counter++;
  }
  return entries;
}, "se_Values");
var de_AlarmHistoryItem = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_ANl] != null) {
    contents[_ANl] = (0, import_smithy_client.expectString)(output[_ANl]);
  }
  if (output[_ATl] != null) {
    contents[_ATl] = (0, import_smithy_client.expectString)(output[_ATl]);
  }
  if (output[_Ti] != null) {
    contents[_Ti] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_Ti]));
  }
  if (output[_HIT] != null) {
    contents[_HIT] = (0, import_smithy_client.expectString)(output[_HIT]);
  }
  if (output[_HS] != null) {
    contents[_HS] = (0, import_smithy_client.expectString)(output[_HS]);
  }
  if (output[_HD] != null) {
    contents[_HD] = (0, import_smithy_client.expectString)(output[_HD]);
  }
  return contents;
}, "de_AlarmHistoryItem");
var de_AlarmHistoryItems = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_AlarmHistoryItem(entry, context);
  });
}, "de_AlarmHistoryItems");
var de_AnomalyDetector = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_N] != null) {
    contents[_N] = (0, import_smithy_client.expectString)(output[_N]);
  }
  if (output[_MN] != null) {
    contents[_MN] = (0, import_smithy_client.expectString)(output[_MN]);
  }
  if (output.Dimensions === "") {
    contents[_D] = [];
  } else if (output[_D] != null && output[_D][_m] != null) {
    contents[_D] = de_Dimensions((0, import_smithy_client.getArrayIfSingleItem)(output[_D][_m]), context);
  }
  if (output[_S] != null) {
    contents[_S] = (0, import_smithy_client.expectString)(output[_S]);
  }
  if (output[_Co] != null) {
    contents[_Co] = de_AnomalyDetectorConfiguration(output[_Co], context);
  }
  if (output[_SV] != null) {
    contents[_SV] = (0, import_smithy_client.expectString)(output[_SV]);
  }
  if (output[_SMAD] != null) {
    contents[_SMAD] = de_SingleMetricAnomalyDetector(output[_SMAD], context);
  }
  if (output[_MMAD] != null) {
    contents[_MMAD] = de_MetricMathAnomalyDetector(output[_MMAD], context);
  }
  return contents;
}, "de_AnomalyDetector");
var de_AnomalyDetectorConfiguration = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.ExcludedTimeRanges === "") {
    contents[_ETR] = [];
  } else if (output[_ETR] != null && output[_ETR][_m] != null) {
    contents[_ETR] = de_AnomalyDetectorExcludedTimeRanges((0, import_smithy_client.getArrayIfSingleItem)(output[_ETR][_m]), context);
  }
  if (output[_MT] != null) {
    contents[_MT] = (0, import_smithy_client.expectString)(output[_MT]);
  }
  return contents;
}, "de_AnomalyDetectorConfiguration");
var de_AnomalyDetectorExcludedTimeRanges = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_Range(entry, context);
  });
}, "de_AnomalyDetectorExcludedTimeRanges");
var de_AnomalyDetectors = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_AnomalyDetector(entry, context);
  });
}, "de_AnomalyDetectors");
var de_BatchFailures = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_PartialFailure(entry, context);
  });
}, "de_BatchFailures");
var de_CompositeAlarm = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_AE] != null) {
    contents[_AE] = (0, import_smithy_client.parseBoolean)(output[_AE]);
  }
  if (output.AlarmActions === "") {
    contents[_AA] = [];
  } else if (output[_AA] != null && output[_AA][_m] != null) {
    contents[_AA] = de_ResourceList((0, import_smithy_client.getArrayIfSingleItem)(output[_AA][_m]), context);
  }
  if (output[_AAl] != null) {
    contents[_AAl] = (0, import_smithy_client.expectString)(output[_AAl]);
  }
  if (output[_ACUT] != null) {
    contents[_ACUT] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_ACUT]));
  }
  if (output[_AD] != null) {
    contents[_AD] = (0, import_smithy_client.expectString)(output[_AD]);
  }
  if (output[_ANl] != null) {
    contents[_ANl] = (0, import_smithy_client.expectString)(output[_ANl]);
  }
  if (output[_AR] != null) {
    contents[_AR] = (0, import_smithy_client.expectString)(output[_AR]);
  }
  if (output.InsufficientDataActions === "") {
    contents[_IDA] = [];
  } else if (output[_IDA] != null && output[_IDA][_m] != null) {
    contents[_IDA] = de_ResourceList((0, import_smithy_client.getArrayIfSingleItem)(output[_IDA][_m]), context);
  }
  if (output.OKActions === "") {
    contents[_OKA] = [];
  } else if (output[_OKA] != null && output[_OKA][_m] != null) {
    contents[_OKA] = de_ResourceList((0, import_smithy_client.getArrayIfSingleItem)(output[_OKA][_m]), context);
  }
  if (output[_SRt] != null) {
    contents[_SRt] = (0, import_smithy_client.expectString)(output[_SRt]);
  }
  if (output[_SRD] != null) {
    contents[_SRD] = (0, import_smithy_client.expectString)(output[_SRD]);
  }
  if (output[_SUT] != null) {
    contents[_SUT] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_SUT]));
  }
  if (output[_SV] != null) {
    contents[_SV] = (0, import_smithy_client.expectString)(output[_SV]);
  }
  if (output[_STT] != null) {
    contents[_STT] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_STT]));
  }
  if (output[_ASB] != null) {
    contents[_ASB] = (0, import_smithy_client.expectString)(output[_ASB]);
  }
  if (output[_ASR] != null) {
    contents[_ASR] = (0, import_smithy_client.expectString)(output[_ASR]);
  }
  if (output[_ASc] != null) {
    contents[_ASc] = (0, import_smithy_client.expectString)(output[_ASc]);
  }
  if (output[_ASWP] != null) {
    contents[_ASWP] = (0, import_smithy_client.strictParseInt32)(output[_ASWP]);
  }
  if (output[_ASEP] != null) {
    contents[_ASEP] = (0, import_smithy_client.strictParseInt32)(output[_ASEP]);
  }
  return contents;
}, "de_CompositeAlarm");
var de_CompositeAlarms = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_CompositeAlarm(entry, context);
  });
}, "de_CompositeAlarms");
var de_ConcurrentModificationException = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Mes] != null) {
    contents[_Mes] = (0, import_smithy_client.expectString)(output[_Mes]);
  }
  return contents;
}, "de_ConcurrentModificationException");
var de_DashboardEntries = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_DashboardEntry(entry, context);
  });
}, "de_DashboardEntries");
var de_DashboardEntry = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_DNa] != null) {
    contents[_DNa] = (0, import_smithy_client.expectString)(output[_DNa]);
  }
  if (output[_DAa] != null) {
    contents[_DAa] = (0, import_smithy_client.expectString)(output[_DAa]);
  }
  if (output[_LMa] != null) {
    contents[_LMa] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_LMa]));
  }
  if (output[_Si] != null) {
    contents[_Si] = (0, import_smithy_client.strictParseLong)(output[_Si]);
  }
  return contents;
}, "de_DashboardEntry");
var de_DashboardInvalidInputError = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_me] != null) {
    contents[_me] = (0, import_smithy_client.expectString)(output[_me]);
  }
  if (output.dashboardValidationMessages === "") {
    contents[_dVM] = [];
  } else if (output[_dVM] != null && output[_dVM][_m] != null) {
    contents[_dVM] = de_DashboardValidationMessages((0, import_smithy_client.getArrayIfSingleItem)(output[_dVM][_m]), context);
  }
  return contents;
}, "de_DashboardInvalidInputError");
var de_DashboardValidationMessage = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_DP] != null) {
    contents[_DP] = (0, import_smithy_client.expectString)(output[_DP]);
  }
  if (output[_Mes] != null) {
    contents[_Mes] = (0, import_smithy_client.expectString)(output[_Mes]);
  }
  return contents;
}, "de_DashboardValidationMessage");
var de_DashboardValidationMessages = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_DashboardValidationMessage(entry, context);
  });
}, "de_DashboardValidationMessages");
var de_Datapoint = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Ti] != null) {
    contents[_Ti] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_Ti]));
  }
  if (output[_SCa] != null) {
    contents[_SCa] = (0, import_smithy_client.strictParseFloat)(output[_SCa]);
  }
  if (output[_Av] != null) {
    contents[_Av] = (0, import_smithy_client.strictParseFloat)(output[_Av]);
  }
  if (output[_Su] != null) {
    contents[_Su] = (0, import_smithy_client.strictParseFloat)(output[_Su]);
  }
  if (output[_Mi] != null) {
    contents[_Mi] = (0, import_smithy_client.strictParseFloat)(output[_Mi]);
  }
  if (output[_Ma] != null) {
    contents[_Ma] = (0, import_smithy_client.strictParseFloat)(output[_Ma]);
  }
  if (output[_U] != null) {
    contents[_U] = (0, import_smithy_client.expectString)(output[_U]);
  }
  if (output.ExtendedStatistics === "") {
    contents[_ESx] = {};
  } else if (output[_ESx] != null && output[_ESx][_e] != null) {
    contents[_ESx] = de_DatapointValueMap((0, import_smithy_client.getArrayIfSingleItem)(output[_ESx][_e]), context);
  }
  return contents;
}, "de_Datapoint");
var de_Datapoints = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_Datapoint(entry, context);
  });
}, "de_Datapoints");
var de_DatapointValueMap = /* @__PURE__ */ __name((output, context) => {
  return output.reduce((acc, pair) => {
    if (pair["value"] === null) {
      return acc;
    }
    acc[pair["key"]] = (0, import_smithy_client.strictParseFloat)(pair["value"]);
    return acc;
  }, {});
}, "de_DatapointValueMap");
var de_DatapointValues = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return (0, import_smithy_client.strictParseFloat)(entry);
  });
}, "de_DatapointValues");
var de_DeleteAnomalyDetectorOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  return contents;
}, "de_DeleteAnomalyDetectorOutput");
var de_DeleteDashboardsOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  return contents;
}, "de_DeleteDashboardsOutput");
var de_DeleteInsightRulesOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.Failures === "") {
    contents[_F] = [];
  } else if (output[_F] != null && output[_F][_m] != null) {
    contents[_F] = de_BatchFailures((0, import_smithy_client.getArrayIfSingleItem)(output[_F][_m]), context);
  }
  return contents;
}, "de_DeleteInsightRulesOutput");
var de_DeleteMetricStreamOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  return contents;
}, "de_DeleteMetricStreamOutput");
var de_DescribeAlarmHistoryOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.AlarmHistoryItems === "") {
    contents[_AHI] = [];
  } else if (output[_AHI] != null && output[_AHI][_m] != null) {
    contents[_AHI] = de_AlarmHistoryItems((0, import_smithy_client.getArrayIfSingleItem)(output[_AHI][_m]), context);
  }
  if (output[_NT] != null) {
    contents[_NT] = (0, import_smithy_client.expectString)(output[_NT]);
  }
  return contents;
}, "de_DescribeAlarmHistoryOutput");
var de_DescribeAlarmsForMetricOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.MetricAlarms === "") {
    contents[_MA] = [];
  } else if (output[_MA] != null && output[_MA][_m] != null) {
    contents[_MA] = de_MetricAlarms((0, import_smithy_client.getArrayIfSingleItem)(output[_MA][_m]), context);
  }
  return contents;
}, "de_DescribeAlarmsForMetricOutput");
var de_DescribeAlarmsOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.CompositeAlarms === "") {
    contents[_CA] = [];
  } else if (output[_CA] != null && output[_CA][_m] != null) {
    contents[_CA] = de_CompositeAlarms((0, import_smithy_client.getArrayIfSingleItem)(output[_CA][_m]), context);
  }
  if (output.MetricAlarms === "") {
    contents[_MA] = [];
  } else if (output[_MA] != null && output[_MA][_m] != null) {
    contents[_MA] = de_MetricAlarms((0, import_smithy_client.getArrayIfSingleItem)(output[_MA][_m]), context);
  }
  if (output[_NT] != null) {
    contents[_NT] = (0, import_smithy_client.expectString)(output[_NT]);
  }
  return contents;
}, "de_DescribeAlarmsOutput");
var de_DescribeAnomalyDetectorsOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.AnomalyDetectors === "") {
    contents[_ADn] = [];
  } else if (output[_ADn] != null && output[_ADn][_m] != null) {
    contents[_ADn] = de_AnomalyDetectors((0, import_smithy_client.getArrayIfSingleItem)(output[_ADn][_m]), context);
  }
  if (output[_NT] != null) {
    contents[_NT] = (0, import_smithy_client.expectString)(output[_NT]);
  }
  return contents;
}, "de_DescribeAnomalyDetectorsOutput");
var de_DescribeInsightRulesOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_NT] != null) {
    contents[_NT] = (0, import_smithy_client.expectString)(output[_NT]);
  }
  if (output.InsightRules === "") {
    contents[_IR] = [];
  } else if (output[_IR] != null && output[_IR][_m] != null) {
    contents[_IR] = de_InsightRules((0, import_smithy_client.getArrayIfSingleItem)(output[_IR][_m]), context);
  }
  return contents;
}, "de_DescribeInsightRulesOutput");
var de_Dimension = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Na] != null) {
    contents[_Na] = (0, import_smithy_client.expectString)(output[_Na]);
  }
  if (output[_Va] != null) {
    contents[_Va] = (0, import_smithy_client.expectString)(output[_Va]);
  }
  return contents;
}, "de_Dimension");
var de_Dimensions = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_Dimension(entry, context);
  });
}, "de_Dimensions");
var de_DisableInsightRulesOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.Failures === "") {
    contents[_F] = [];
  } else if (output[_F] != null && output[_F][_m] != null) {
    contents[_F] = de_BatchFailures((0, import_smithy_client.getArrayIfSingleItem)(output[_F][_m]), context);
  }
  return contents;
}, "de_DisableInsightRulesOutput");
var de_EnableInsightRulesOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.Failures === "") {
    contents[_F] = [];
  } else if (output[_F] != null && output[_F][_m] != null) {
    contents[_F] = de_BatchFailures((0, import_smithy_client.getArrayIfSingleItem)(output[_F][_m]), context);
  }
  return contents;
}, "de_EnableInsightRulesOutput");
var de_GetDashboardOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_DAa] != null) {
    contents[_DAa] = (0, import_smithy_client.expectString)(output[_DAa]);
  }
  if (output[_DB] != null) {
    contents[_DB] = (0, import_smithy_client.expectString)(output[_DB]);
  }
  if (output[_DNa] != null) {
    contents[_DNa] = (0, import_smithy_client.expectString)(output[_DNa]);
  }
  return contents;
}, "de_GetDashboardOutput");
var de_GetInsightRuleReportOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.KeyLabels === "") {
    contents[_KL] = [];
  } else if (output[_KL] != null && output[_KL][_m] != null) {
    contents[_KL] = de_InsightRuleContributorKeyLabels((0, import_smithy_client.getArrayIfSingleItem)(output[_KL][_m]), context);
  }
  if (output[_ASg] != null) {
    contents[_ASg] = (0, import_smithy_client.expectString)(output[_ASg]);
  }
  if (output[_AV] != null) {
    contents[_AV] = (0, import_smithy_client.strictParseFloat)(output[_AV]);
  }
  if (output[_AUC] != null) {
    contents[_AUC] = (0, import_smithy_client.strictParseLong)(output[_AUC]);
  }
  if (output.Contributors === "") {
    contents[_Con] = [];
  } else if (output[_Con] != null && output[_Con][_m] != null) {
    contents[_Con] = de_InsightRuleContributors((0, import_smithy_client.getArrayIfSingleItem)(output[_Con][_m]), context);
  }
  if (output.MetricDatapoints === "") {
    contents[_MDet] = [];
  } else if (output[_MDet] != null && output[_MDet][_m] != null) {
    contents[_MDet] = de_InsightRuleMetricDatapoints((0, import_smithy_client.getArrayIfSingleItem)(output[_MDet][_m]), context);
  }
  return contents;
}, "de_GetInsightRuleReportOutput");
var de_GetMetricDataOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.MetricDataResults === "") {
    contents[_MDR] = [];
  } else if (output[_MDR] != null && output[_MDR][_m] != null) {
    contents[_MDR] = de_MetricDataResults((0, import_smithy_client.getArrayIfSingleItem)(output[_MDR][_m]), context);
  }
  if (output[_NT] != null) {
    contents[_NT] = (0, import_smithy_client.expectString)(output[_NT]);
  }
  if (output.Messages === "") {
    contents[_Mess] = [];
  } else if (output[_Mess] != null && output[_Mess][_m] != null) {
    contents[_Mess] = de_MetricDataResultMessages((0, import_smithy_client.getArrayIfSingleItem)(output[_Mess][_m]), context);
  }
  return contents;
}, "de_GetMetricDataOutput");
var de_GetMetricStatisticsOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_L] != null) {
    contents[_L] = (0, import_smithy_client.expectString)(output[_L]);
  }
  if (output.Datapoints === "") {
    contents[_Da] = [];
  } else if (output[_Da] != null && output[_Da][_m] != null) {
    contents[_Da] = de_Datapoints((0, import_smithy_client.getArrayIfSingleItem)(output[_Da][_m]), context);
  }
  return contents;
}, "de_GetMetricStatisticsOutput");
var de_GetMetricStreamOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Ar] != null) {
    contents[_Ar] = (0, import_smithy_client.expectString)(output[_Ar]);
  }
  if (output[_Na] != null) {
    contents[_Na] = (0, import_smithy_client.expectString)(output[_Na]);
  }
  if (output.IncludeFilters === "") {
    contents[_IF] = [];
  } else if (output[_IF] != null && output[_IF][_m] != null) {
    contents[_IF] = de_MetricStreamFilters((0, import_smithy_client.getArrayIfSingleItem)(output[_IF][_m]), context);
  }
  if (output.ExcludeFilters === "") {
    contents[_EF] = [];
  } else if (output[_EF] != null && output[_EF][_m] != null) {
    contents[_EF] = de_MetricStreamFilters((0, import_smithy_client.getArrayIfSingleItem)(output[_EF][_m]), context);
  }
  if (output[_FA] != null) {
    contents[_FA] = (0, import_smithy_client.expectString)(output[_FA]);
  }
  if (output[_RAo] != null) {
    contents[_RAo] = (0, import_smithy_client.expectString)(output[_RAo]);
  }
  if (output[_Stat] != null) {
    contents[_Stat] = (0, import_smithy_client.expectString)(output[_Stat]);
  }
  if (output[_CD] != null) {
    contents[_CD] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_CD]));
  }
  if (output[_LUD] != null) {
    contents[_LUD] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_LUD]));
  }
  if (output[_OF] != null) {
    contents[_OF] = (0, import_smithy_client.expectString)(output[_OF]);
  }
  if (output.StatisticsConfigurations === "") {
    contents[_SC] = [];
  } else if (output[_SC] != null && output[_SC][_m] != null) {
    contents[_SC] = de_MetricStreamStatisticsConfigurations((0, import_smithy_client.getArrayIfSingleItem)(output[_SC][_m]), context);
  }
  if (output[_ILAM] != null) {
    contents[_ILAM] = (0, import_smithy_client.parseBoolean)(output[_ILAM]);
  }
  return contents;
}, "de_GetMetricStreamOutput");
var de_GetMetricWidgetImageOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_MWI] != null) {
    contents[_MWI] = context.base64Decoder(output[_MWI]);
  }
  return contents;
}, "de_GetMetricWidgetImageOutput");
var de_InsightRule = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Na] != null) {
    contents[_Na] = (0, import_smithy_client.expectString)(output[_Na]);
  }
  if (output[_Stat] != null) {
    contents[_Stat] = (0, import_smithy_client.expectString)(output[_Stat]);
  }
  if (output[_Sc] != null) {
    contents[_Sc] = (0, import_smithy_client.expectString)(output[_Sc]);
  }
  if (output[_De] != null) {
    contents[_De] = (0, import_smithy_client.expectString)(output[_De]);
  }
  if (output[_MRana] != null) {
    contents[_MRana] = (0, import_smithy_client.parseBoolean)(output[_MRana]);
  }
  return contents;
}, "de_InsightRule");
var de_InsightRuleContributor = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.Keys === "") {
    contents[_Ke] = [];
  } else if (output[_Ke] != null && output[_Ke][_m] != null) {
    contents[_Ke] = de_InsightRuleContributorKeys((0, import_smithy_client.getArrayIfSingleItem)(output[_Ke][_m]), context);
  }
  if (output[_AAV] != null) {
    contents[_AAV] = (0, import_smithy_client.strictParseFloat)(output[_AAV]);
  }
  if (output.Datapoints === "") {
    contents[_Da] = [];
  } else if (output[_Da] != null && output[_Da][_m] != null) {
    contents[_Da] = de_InsightRuleContributorDatapoints((0, import_smithy_client.getArrayIfSingleItem)(output[_Da][_m]), context);
  }
  return contents;
}, "de_InsightRuleContributor");
var de_InsightRuleContributorDatapoint = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Ti] != null) {
    contents[_Ti] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_Ti]));
  }
  if (output[_AVp] != null) {
    contents[_AVp] = (0, import_smithy_client.strictParseFloat)(output[_AVp]);
  }
  return contents;
}, "de_InsightRuleContributorDatapoint");
var de_InsightRuleContributorDatapoints = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_InsightRuleContributorDatapoint(entry, context);
  });
}, "de_InsightRuleContributorDatapoints");
var de_InsightRuleContributorKeyLabels = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return (0, import_smithy_client.expectString)(entry);
  });
}, "de_InsightRuleContributorKeyLabels");
var de_InsightRuleContributorKeys = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return (0, import_smithy_client.expectString)(entry);
  });
}, "de_InsightRuleContributorKeys");
var de_InsightRuleContributors = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_InsightRuleContributor(entry, context);
  });
}, "de_InsightRuleContributors");
var de_InsightRuleMetricDatapoint = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Ti] != null) {
    contents[_Ti] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_Ti]));
  }
  if (output[_UC] != null) {
    contents[_UC] = (0, import_smithy_client.strictParseFloat)(output[_UC]);
  }
  if (output[_MCV] != null) {
    contents[_MCV] = (0, import_smithy_client.strictParseFloat)(output[_MCV]);
  }
  if (output[_SCa] != null) {
    contents[_SCa] = (0, import_smithy_client.strictParseFloat)(output[_SCa]);
  }
  if (output[_Av] != null) {
    contents[_Av] = (0, import_smithy_client.strictParseFloat)(output[_Av]);
  }
  if (output[_Su] != null) {
    contents[_Su] = (0, import_smithy_client.strictParseFloat)(output[_Su]);
  }
  if (output[_Mi] != null) {
    contents[_Mi] = (0, import_smithy_client.strictParseFloat)(output[_Mi]);
  }
  if (output[_Ma] != null) {
    contents[_Ma] = (0, import_smithy_client.strictParseFloat)(output[_Ma]);
  }
  return contents;
}, "de_InsightRuleMetricDatapoint");
var de_InsightRuleMetricDatapoints = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_InsightRuleMetricDatapoint(entry, context);
  });
}, "de_InsightRuleMetricDatapoints");
var de_InsightRules = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_InsightRule(entry, context);
  });
}, "de_InsightRules");
var de_InternalServiceFault = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Mes] != null) {
    contents[_Mes] = (0, import_smithy_client.expectString)(output[_Mes]);
  }
  return contents;
}, "de_InternalServiceFault");
var de_InvalidFormatFault = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_me] != null) {
    contents[_me] = (0, import_smithy_client.expectString)(output[_me]);
  }
  return contents;
}, "de_InvalidFormatFault");
var de_InvalidNextToken = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_me] != null) {
    contents[_me] = (0, import_smithy_client.expectString)(output[_me]);
  }
  return contents;
}, "de_InvalidNextToken");
var de_InvalidParameterCombinationException = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_me] != null) {
    contents[_me] = (0, import_smithy_client.expectString)(output[_me]);
  }
  return contents;
}, "de_InvalidParameterCombinationException");
var de_InvalidParameterValueException = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_me] != null) {
    contents[_me] = (0, import_smithy_client.expectString)(output[_me]);
  }
  return contents;
}, "de_InvalidParameterValueException");
var de_LimitExceededException = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Mes] != null) {
    contents[_Mes] = (0, import_smithy_client.expectString)(output[_Mes]);
  }
  return contents;
}, "de_LimitExceededException");
var de_LimitExceededFault = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_me] != null) {
    contents[_me] = (0, import_smithy_client.expectString)(output[_me]);
  }
  return contents;
}, "de_LimitExceededFault");
var de_ListDashboardsOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.DashboardEntries === "") {
    contents[_DE] = [];
  } else if (output[_DE] != null && output[_DE][_m] != null) {
    contents[_DE] = de_DashboardEntries((0, import_smithy_client.getArrayIfSingleItem)(output[_DE][_m]), context);
  }
  if (output[_NT] != null) {
    contents[_NT] = (0, import_smithy_client.expectString)(output[_NT]);
  }
  return contents;
}, "de_ListDashboardsOutput");
var de_ListManagedInsightRulesOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.ManagedRules === "") {
    contents[_MRan] = [];
  } else if (output[_MRan] != null && output[_MRan][_m] != null) {
    contents[_MRan] = de_ManagedRuleDescriptions((0, import_smithy_client.getArrayIfSingleItem)(output[_MRan][_m]), context);
  }
  if (output[_NT] != null) {
    contents[_NT] = (0, import_smithy_client.expectString)(output[_NT]);
  }
  return contents;
}, "de_ListManagedInsightRulesOutput");
var de_ListMetricsOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.Metrics === "") {
    contents[_M] = [];
  } else if (output[_M] != null && output[_M][_m] != null) {
    contents[_M] = de_Metrics((0, import_smithy_client.getArrayIfSingleItem)(output[_M][_m]), context);
  }
  if (output[_NT] != null) {
    contents[_NT] = (0, import_smithy_client.expectString)(output[_NT]);
  }
  if (output.OwningAccounts === "") {
    contents[_OAw] = [];
  } else if (output[_OAw] != null && output[_OAw][_m] != null) {
    contents[_OAw] = de_OwningAccounts((0, import_smithy_client.getArrayIfSingleItem)(output[_OAw][_m]), context);
  }
  return contents;
}, "de_ListMetricsOutput");
var de_ListMetricStreamsOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_NT] != null) {
    contents[_NT] = (0, import_smithy_client.expectString)(output[_NT]);
  }
  if (output.Entries === "") {
    contents[_En] = [];
  } else if (output[_En] != null && output[_En][_m] != null) {
    contents[_En] = de_MetricStreamEntries((0, import_smithy_client.getArrayIfSingleItem)(output[_En][_m]), context);
  }
  return contents;
}, "de_ListMetricStreamsOutput");
var de_ListTagsForResourceOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.Tags === "") {
    contents[_Ta] = [];
  } else if (output[_Ta] != null && output[_Ta][_m] != null) {
    contents[_Ta] = de_TagList((0, import_smithy_client.getArrayIfSingleItem)(output[_Ta][_m]), context);
  }
  return contents;
}, "de_ListTagsForResourceOutput");
var de_ManagedRuleDescription = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_TN] != null) {
    contents[_TN] = (0, import_smithy_client.expectString)(output[_TN]);
  }
  if (output[_RARN] != null) {
    contents[_RARN] = (0, import_smithy_client.expectString)(output[_RARN]);
  }
  if (output[_RS] != null) {
    contents[_RS] = de_ManagedRuleState(output[_RS], context);
  }
  return contents;
}, "de_ManagedRuleDescription");
var de_ManagedRuleDescriptions = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_ManagedRuleDescription(entry, context);
  });
}, "de_ManagedRuleDescriptions");
var de_ManagedRuleState = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_RNu] != null) {
    contents[_RNu] = (0, import_smithy_client.expectString)(output[_RNu]);
  }
  if (output[_Stat] != null) {
    contents[_Stat] = (0, import_smithy_client.expectString)(output[_Stat]);
  }
  return contents;
}, "de_ManagedRuleState");
var de_MessageData = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Cod] != null) {
    contents[_Cod] = (0, import_smithy_client.expectString)(output[_Cod]);
  }
  if (output[_Va] != null) {
    contents[_Va] = (0, import_smithy_client.expectString)(output[_Va]);
  }
  return contents;
}, "de_MessageData");
var de_Metric = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_N] != null) {
    contents[_N] = (0, import_smithy_client.expectString)(output[_N]);
  }
  if (output[_MN] != null) {
    contents[_MN] = (0, import_smithy_client.expectString)(output[_MN]);
  }
  if (output.Dimensions === "") {
    contents[_D] = [];
  } else if (output[_D] != null && output[_D][_m] != null) {
    contents[_D] = de_Dimensions((0, import_smithy_client.getArrayIfSingleItem)(output[_D][_m]), context);
  }
  return contents;
}, "de_Metric");
var de_MetricAlarm = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_ANl] != null) {
    contents[_ANl] = (0, import_smithy_client.expectString)(output[_ANl]);
  }
  if (output[_AAl] != null) {
    contents[_AAl] = (0, import_smithy_client.expectString)(output[_AAl]);
  }
  if (output[_AD] != null) {
    contents[_AD] = (0, import_smithy_client.expectString)(output[_AD]);
  }
  if (output[_ACUT] != null) {
    contents[_ACUT] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_ACUT]));
  }
  if (output[_AE] != null) {
    contents[_AE] = (0, import_smithy_client.parseBoolean)(output[_AE]);
  }
  if (output.OKActions === "") {
    contents[_OKA] = [];
  } else if (output[_OKA] != null && output[_OKA][_m] != null) {
    contents[_OKA] = de_ResourceList((0, import_smithy_client.getArrayIfSingleItem)(output[_OKA][_m]), context);
  }
  if (output.AlarmActions === "") {
    contents[_AA] = [];
  } else if (output[_AA] != null && output[_AA][_m] != null) {
    contents[_AA] = de_ResourceList((0, import_smithy_client.getArrayIfSingleItem)(output[_AA][_m]), context);
  }
  if (output.InsufficientDataActions === "") {
    contents[_IDA] = [];
  } else if (output[_IDA] != null && output[_IDA][_m] != null) {
    contents[_IDA] = de_ResourceList((0, import_smithy_client.getArrayIfSingleItem)(output[_IDA][_m]), context);
  }
  if (output[_SV] != null) {
    contents[_SV] = (0, import_smithy_client.expectString)(output[_SV]);
  }
  if (output[_SRt] != null) {
    contents[_SRt] = (0, import_smithy_client.expectString)(output[_SRt]);
  }
  if (output[_SRD] != null) {
    contents[_SRD] = (0, import_smithy_client.expectString)(output[_SRD]);
  }
  if (output[_SUT] != null) {
    contents[_SUT] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_SUT]));
  }
  if (output[_MN] != null) {
    contents[_MN] = (0, import_smithy_client.expectString)(output[_MN]);
  }
  if (output[_N] != null) {
    contents[_N] = (0, import_smithy_client.expectString)(output[_N]);
  }
  if (output[_St] != null) {
    contents[_St] = (0, import_smithy_client.expectString)(output[_St]);
  }
  if (output[_ES] != null) {
    contents[_ES] = (0, import_smithy_client.expectString)(output[_ES]);
  }
  if (output.Dimensions === "") {
    contents[_D] = [];
  } else if (output[_D] != null && output[_D][_m] != null) {
    contents[_D] = de_Dimensions((0, import_smithy_client.getArrayIfSingleItem)(output[_D][_m]), context);
  }
  if (output[_P] != null) {
    contents[_P] = (0, import_smithy_client.strictParseInt32)(output[_P]);
  }
  if (output[_U] != null) {
    contents[_U] = (0, import_smithy_client.expectString)(output[_U]);
  }
  if (output[_EP] != null) {
    contents[_EP] = (0, import_smithy_client.strictParseInt32)(output[_EP]);
  }
  if (output[_DTA] != null) {
    contents[_DTA] = (0, import_smithy_client.strictParseInt32)(output[_DTA]);
  }
  if (output[_Th] != null) {
    contents[_Th] = (0, import_smithy_client.strictParseFloat)(output[_Th]);
  }
  if (output[_CO] != null) {
    contents[_CO] = (0, import_smithy_client.expectString)(output[_CO]);
  }
  if (output[_TMD] != null) {
    contents[_TMD] = (0, import_smithy_client.expectString)(output[_TMD]);
  }
  if (output[_ELSCP] != null) {
    contents[_ELSCP] = (0, import_smithy_client.expectString)(output[_ELSCP]);
  }
  if (output.Metrics === "") {
    contents[_M] = [];
  } else if (output[_M] != null && output[_M][_m] != null) {
    contents[_M] = de_MetricDataQueries((0, import_smithy_client.getArrayIfSingleItem)(output[_M][_m]), context);
  }
  if (output[_TMI] != null) {
    contents[_TMI] = (0, import_smithy_client.expectString)(output[_TMI]);
  }
  if (output[_ESv] != null) {
    contents[_ESv] = (0, import_smithy_client.expectString)(output[_ESv]);
  }
  if (output[_STT] != null) {
    contents[_STT] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_STT]));
  }
  return contents;
}, "de_MetricAlarm");
var de_MetricAlarms = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_MetricAlarm(entry, context);
  });
}, "de_MetricAlarms");
var de_MetricDataQueries = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_MetricDataQuery(entry, context);
  });
}, "de_MetricDataQueries");
var de_MetricDataQuery = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_I] != null) {
    contents[_I] = (0, import_smithy_client.expectString)(output[_I]);
  }
  if (output[_MS] != null) {
    contents[_MS] = de_MetricStat(output[_MS], context);
  }
  if (output[_E] != null) {
    contents[_E] = (0, import_smithy_client.expectString)(output[_E]);
  }
  if (output[_L] != null) {
    contents[_L] = (0, import_smithy_client.expectString)(output[_L]);
  }
  if (output[_RD] != null) {
    contents[_RD] = (0, import_smithy_client.parseBoolean)(output[_RD]);
  }
  if (output[_P] != null) {
    contents[_P] = (0, import_smithy_client.strictParseInt32)(output[_P]);
  }
  if (output[_AI] != null) {
    contents[_AI] = (0, import_smithy_client.expectString)(output[_AI]);
  }
  return contents;
}, "de_MetricDataQuery");
var de_MetricDataResult = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_I] != null) {
    contents[_I] = (0, import_smithy_client.expectString)(output[_I]);
  }
  if (output[_L] != null) {
    contents[_L] = (0, import_smithy_client.expectString)(output[_L]);
  }
  if (output.Timestamps === "") {
    contents[_Tim] = [];
  } else if (output[_Tim] != null && output[_Tim][_m] != null) {
    contents[_Tim] = de_Timestamps((0, import_smithy_client.getArrayIfSingleItem)(output[_Tim][_m]), context);
  }
  if (output.Values === "") {
    contents[_Val] = [];
  } else if (output[_Val] != null && output[_Val][_m] != null) {
    contents[_Val] = de_DatapointValues((0, import_smithy_client.getArrayIfSingleItem)(output[_Val][_m]), context);
  }
  if (output[_SCt] != null) {
    contents[_SCt] = (0, import_smithy_client.expectString)(output[_SCt]);
  }
  if (output.Messages === "") {
    contents[_Mess] = [];
  } else if (output[_Mess] != null && output[_Mess][_m] != null) {
    contents[_Mess] = de_MetricDataResultMessages((0, import_smithy_client.getArrayIfSingleItem)(output[_Mess][_m]), context);
  }
  return contents;
}, "de_MetricDataResult");
var de_MetricDataResultMessages = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_MessageData(entry, context);
  });
}, "de_MetricDataResultMessages");
var de_MetricDataResults = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_MetricDataResult(entry, context);
  });
}, "de_MetricDataResults");
var de_MetricMathAnomalyDetector = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.MetricDataQueries === "") {
    contents[_MDQ] = [];
  } else if (output[_MDQ] != null && output[_MDQ][_m] != null) {
    contents[_MDQ] = de_MetricDataQueries((0, import_smithy_client.getArrayIfSingleItem)(output[_MDQ][_m]), context);
  }
  return contents;
}, "de_MetricMathAnomalyDetector");
var de_Metrics = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_Metric(entry, context);
  });
}, "de_Metrics");
var de_MetricStat = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Me] != null) {
    contents[_Me] = de_Metric(output[_Me], context);
  }
  if (output[_P] != null) {
    contents[_P] = (0, import_smithy_client.strictParseInt32)(output[_P]);
  }
  if (output[_S] != null) {
    contents[_S] = (0, import_smithy_client.expectString)(output[_S]);
  }
  if (output[_U] != null) {
    contents[_U] = (0, import_smithy_client.expectString)(output[_U]);
  }
  return contents;
}, "de_MetricStat");
var de_MetricStreamEntries = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_MetricStreamEntry(entry, context);
  });
}, "de_MetricStreamEntries");
var de_MetricStreamEntry = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Ar] != null) {
    contents[_Ar] = (0, import_smithy_client.expectString)(output[_Ar]);
  }
  if (output[_CD] != null) {
    contents[_CD] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_CD]));
  }
  if (output[_LUD] != null) {
    contents[_LUD] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_LUD]));
  }
  if (output[_Na] != null) {
    contents[_Na] = (0, import_smithy_client.expectString)(output[_Na]);
  }
  if (output[_FA] != null) {
    contents[_FA] = (0, import_smithy_client.expectString)(output[_FA]);
  }
  if (output[_Stat] != null) {
    contents[_Stat] = (0, import_smithy_client.expectString)(output[_Stat]);
  }
  if (output[_OF] != null) {
    contents[_OF] = (0, import_smithy_client.expectString)(output[_OF]);
  }
  return contents;
}, "de_MetricStreamEntry");
var de_MetricStreamFilter = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_N] != null) {
    contents[_N] = (0, import_smithy_client.expectString)(output[_N]);
  }
  if (output.MetricNames === "") {
    contents[_MNe] = [];
  } else if (output[_MNe] != null && output[_MNe][_m] != null) {
    contents[_MNe] = de_MetricStreamFilterMetricNames((0, import_smithy_client.getArrayIfSingleItem)(output[_MNe][_m]), context);
  }
  return contents;
}, "de_MetricStreamFilter");
var de_MetricStreamFilterMetricNames = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return (0, import_smithy_client.expectString)(entry);
  });
}, "de_MetricStreamFilterMetricNames");
var de_MetricStreamFilters = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_MetricStreamFilter(entry, context);
  });
}, "de_MetricStreamFilters");
var de_MetricStreamStatisticsAdditionalStatistics = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return (0, import_smithy_client.expectString)(entry);
  });
}, "de_MetricStreamStatisticsAdditionalStatistics");
var de_MetricStreamStatisticsConfiguration = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.IncludeMetrics === "") {
    contents[_IM] = [];
  } else if (output[_IM] != null && output[_IM][_m] != null) {
    contents[_IM] = de_MetricStreamStatisticsIncludeMetrics((0, import_smithy_client.getArrayIfSingleItem)(output[_IM][_m]), context);
  }
  if (output.AdditionalStatistics === "") {
    contents[_AS] = [];
  } else if (output[_AS] != null && output[_AS][_m] != null) {
    contents[_AS] = de_MetricStreamStatisticsAdditionalStatistics((0, import_smithy_client.getArrayIfSingleItem)(output[_AS][_m]), context);
  }
  return contents;
}, "de_MetricStreamStatisticsConfiguration");
var de_MetricStreamStatisticsConfigurations = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_MetricStreamStatisticsConfiguration(entry, context);
  });
}, "de_MetricStreamStatisticsConfigurations");
var de_MetricStreamStatisticsIncludeMetrics = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_MetricStreamStatisticsMetric(entry, context);
  });
}, "de_MetricStreamStatisticsIncludeMetrics");
var de_MetricStreamStatisticsMetric = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_N] != null) {
    contents[_N] = (0, import_smithy_client.expectString)(output[_N]);
  }
  if (output[_MN] != null) {
    contents[_MN] = (0, import_smithy_client.expectString)(output[_MN]);
  }
  return contents;
}, "de_MetricStreamStatisticsMetric");
var de_MissingRequiredParameterException = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_me] != null) {
    contents[_me] = (0, import_smithy_client.expectString)(output[_me]);
  }
  return contents;
}, "de_MissingRequiredParameterException");
var de_OwningAccounts = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return (0, import_smithy_client.expectString)(entry);
  });
}, "de_OwningAccounts");
var de_PartialFailure = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_FR] != null) {
    contents[_FR] = (0, import_smithy_client.expectString)(output[_FR]);
  }
  if (output[_ETx] != null) {
    contents[_ETx] = (0, import_smithy_client.expectString)(output[_ETx]);
  }
  if (output[_FC] != null) {
    contents[_FC] = (0, import_smithy_client.expectString)(output[_FC]);
  }
  if (output[_FD] != null) {
    contents[_FD] = (0, import_smithy_client.expectString)(output[_FD]);
  }
  return contents;
}, "de_PartialFailure");
var de_PutAnomalyDetectorOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  return contents;
}, "de_PutAnomalyDetectorOutput");
var de_PutDashboardOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.DashboardValidationMessages === "") {
    contents[_DVM] = [];
  } else if (output[_DVM] != null && output[_DVM][_m] != null) {
    contents[_DVM] = de_DashboardValidationMessages((0, import_smithy_client.getArrayIfSingleItem)(output[_DVM][_m]), context);
  }
  return contents;
}, "de_PutDashboardOutput");
var de_PutInsightRuleOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  return contents;
}, "de_PutInsightRuleOutput");
var de_PutManagedInsightRulesOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output.Failures === "") {
    contents[_F] = [];
  } else if (output[_F] != null && output[_F][_m] != null) {
    contents[_F] = de_BatchFailures((0, import_smithy_client.getArrayIfSingleItem)(output[_F][_m]), context);
  }
  return contents;
}, "de_PutManagedInsightRulesOutput");
var de_PutMetricStreamOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_Ar] != null) {
    contents[_Ar] = (0, import_smithy_client.expectString)(output[_Ar]);
  }
  return contents;
}, "de_PutMetricStreamOutput");
var de_Range = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_ST] != null) {
    contents[_ST] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_ST]));
  }
  if (output[_ET] != null) {
    contents[_ET] = (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(output[_ET]));
  }
  return contents;
}, "de_Range");
var de_ResourceList = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return (0, import_smithy_client.expectString)(entry);
  });
}, "de_ResourceList");
var de_ResourceNotFound = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_me] != null) {
    contents[_me] = (0, import_smithy_client.expectString)(output[_me]);
  }
  return contents;
}, "de_ResourceNotFound");
var de_ResourceNotFoundException = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_RT] != null) {
    contents[_RT] = (0, import_smithy_client.expectString)(output[_RT]);
  }
  if (output[_RI] != null) {
    contents[_RI] = (0, import_smithy_client.expectString)(output[_RI]);
  }
  if (output[_Mes] != null) {
    contents[_Mes] = (0, import_smithy_client.expectString)(output[_Mes]);
  }
  return contents;
}, "de_ResourceNotFoundException");
var de_SingleMetricAnomalyDetector = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_N] != null) {
    contents[_N] = (0, import_smithy_client.expectString)(output[_N]);
  }
  if (output[_MN] != null) {
    contents[_MN] = (0, import_smithy_client.expectString)(output[_MN]);
  }
  if (output.Dimensions === "") {
    contents[_D] = [];
  } else if (output[_D] != null && output[_D][_m] != null) {
    contents[_D] = de_Dimensions((0, import_smithy_client.getArrayIfSingleItem)(output[_D][_m]), context);
  }
  if (output[_S] != null) {
    contents[_S] = (0, import_smithy_client.expectString)(output[_S]);
  }
  return contents;
}, "de_SingleMetricAnomalyDetector");
var de_StartMetricStreamsOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  return contents;
}, "de_StartMetricStreamsOutput");
var de_StopMetricStreamsOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  return contents;
}, "de_StopMetricStreamsOutput");
var de_Tag = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  if (output[_K] != null) {
    contents[_K] = (0, import_smithy_client.expectString)(output[_K]);
  }
  if (output[_Va] != null) {
    contents[_Va] = (0, import_smithy_client.expectString)(output[_Va]);
  }
  return contents;
}, "de_Tag");
var de_TagList = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return de_Tag(entry, context);
  });
}, "de_TagList");
var de_TagResourceOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  return contents;
}, "de_TagResourceOutput");
var de_Timestamps = /* @__PURE__ */ __name((output, context) => {
  return (output || []).filter((e) => e != null).map((entry) => {
    return (0, import_smithy_client.expectNonNull)((0, import_smithy_client.parseRfc3339DateTimeWithOffset)(entry));
  });
}, "de_Timestamps");
var de_UntagResourceOutput = /* @__PURE__ */ __name((output, context) => {
  const contents = {};
  return contents;
}, "de_UntagResourceOutput");
var deserializeMetadata = /* @__PURE__ */ __name((output) => ({
  httpStatusCode: output.statusCode,
  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
  extendedRequestId: output.headers["x-amz-id-2"],
  cfId: output.headers["x-amz-cf-id"]
}), "deserializeMetadata");
var collectBodyString = /* @__PURE__ */ __name((streamBody, context) => (0, import_smithy_client.collectBody)(streamBody, context).then((body) => context.utf8Encoder(body)), "collectBodyString");
var throwDefaultError = (0, import_smithy_client.withBaseException)(CloudWatchServiceException);
var buildHttpRpcRequest = /* @__PURE__ */ __name(async (context, headers, path, resolvedHostname, body) => {
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
  const contents = {
    protocol,
    hostname,
    port,
    method: "POST",
    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
    headers
  };
  if (resolvedHostname !== void 0) {
    contents.hostname = resolvedHostname;
  }
  if (body !== void 0) {
    contents.body = body;
  }
  return new import_protocol_http.HttpRequest(contents);
}, "buildHttpRpcRequest");
var SHARED_HEADERS = {
  "content-type": "application/x-www-form-urlencoded"
};
var _ = "2010-08-01";
var _A = "Action";
var _AA = "AlarmActions";
var _AAV = "ApproximateAggregateValue";
var _AAl = "AlarmArn";
var _ACUT = "AlarmConfigurationUpdatedTimestamp";
var _AD = "AlarmDescription";
var _ADT = "AnomalyDetectorTypes";
var _ADn = "AnomalyDetectors";
var _AE = "ActionsEnabled";
var _AHI = "AlarmHistoryItems";
var _AI = "AccountId";
var _AN = "AlarmNames";
var _ANP = "AlarmNamePrefix";
var _ANl = "AlarmName";
var _AP = "ActionPrefix";
var _AR = "AlarmRule";
var _AS = "AdditionalStatistics";
var _ASB = "ActionsSuppressedBy";
var _ASEP = "ActionsSuppressorExtensionPeriod";
var _ASR = "ActionsSuppressedReason";
var _ASWP = "ActionsSuppressorWaitPeriod";
var _ASc = "ActionsSuppressor";
var _ASg = "AggregationStatistic";
var _AT = "AlarmTypes";
var _ATl = "AlarmType";
var _AUC = "ApproximateUniqueCount";
var _AV = "AggregateValue";
var _AVp = "ApproximateValue";
var _Ar = "Arn";
var _Av = "Average";
var _C = "Counts";
var _CA = "CompositeAlarms";
var _CD = "CreationDate";
var _CO = "ComparisonOperator";
var _COAN = "ChildrenOfAlarmName";
var _Co = "Configuration";
var _Cod = "Code";
var _Con = "Contributors";
var _D = "Dimensions";
var _DA = "DeleteAlarms";
var _DAA = "DisableAlarmActions";
var _DAD = "DeleteAnomalyDetector";
var _DADe = "DescribeAnomalyDetectors";
var _DAFM = "DescribeAlarmsForMetric";
var _DAH = "DescribeAlarmHistory";
var _DAa = "DashboardArn";
var _DAe = "DescribeAlarms";
var _DB = "DashboardBody";
var _DD = "DeleteDashboards";
var _DE = "DashboardEntries";
var _DIR = "DeleteInsightRules";
var _DIRe = "DescribeInsightRules";
var _DIRi = "DisableInsightRules";
var _DMS = "DeleteMetricStream";
var _DN = "DashboardNames";
var _DNP = "DashboardNamePrefix";
var _DNa = "DashboardName";
var _DP = "DataPath";
var _DTA = "DatapointsToAlarm";
var _DVM = "DashboardValidationMessages";
var _Da = "Datapoints";
var _De = "Definition";
var _E = "Expression";
var _EAA = "EnableAlarmActions";
var _ED = "EndDate";
var _EF = "ExcludeFilters";
var _EIR = "EnableInsightRules";
var _ELSCP = "EvaluateLowSampleCountPercentile";
var _EP = "EvaluationPeriods";
var _ES = "ExtendedStatistic";
var _ESv = "EvaluationState";
var _ESx = "ExtendedStatistics";
var _ET = "EndTime";
var _ETR = "ExcludedTimeRanges";
var _ETx = "ExceptionType";
var _En = "Entries";
var _F = "Failures";
var _FA = "FirehoseArn";
var _FC = "FailureCode";
var _FD = "FailureDescription";
var _FR = "FailureResource";
var _GD = "GetDashboard";
var _GIRR = "GetInsightRuleReport";
var _GMD = "GetMetricData";
var _GMS = "GetMetricStatistics";
var _GMSe = "GetMetricStream";
var _GMWI = "GetMetricWidgetImage";
var _HD = "HistoryData";
var _HIT = "HistoryItemType";
var _HS = "HistorySummary";
var _I = "Id";
var _IDA = "InsufficientDataActions";
var _IF = "IncludeFilters";
var _ILA = "IncludeLinkedAccounts";
var _ILAM = "IncludeLinkedAccountsMetrics";
var _IM = "IncludeMetrics";
var _IR = "InsightRules";
var _K = "Key";
var _KL = "KeyLabels";
var _Ke = "Keys";
var _L = "Label";
var _LD = "ListDashboards";
var _LM = "ListMetrics";
var _LMIR = "ListManagedInsightRules";
var _LMS = "ListMetricStreams";
var _LMa = "LastModified";
var _LO = "LabelOptions";
var _LTFR = "ListTagsForResource";
var _LUD = "LastUpdateDate";
var _M = "Metrics";
var _MA = "MetricAlarms";
var _MCC = "MaxContributorCount";
var _MCV = "MaxContributorValue";
var _MD = "MaxDatapoints";
var _MDQ = "MetricDataQueries";
var _MDR = "MetricDataResults";
var _MDe = "MetricData";
var _MDet = "MetricDatapoints";
var _MMAD = "MetricMathAnomalyDetector";
var _MN = "MetricName";
var _MNe = "MetricNames";
var _MR = "MaxRecords";
var _MRa = "MaxResults";
var _MRan = "ManagedRules";
var _MRana = "ManagedRule";
var _MS = "MetricStat";
var _MT = "MetricTimezone";
var _MW = "MetricWidget";
var _MWI = "MetricWidgetImage";
var _Ma = "Maximum";
var _Me = "Metric";
var _Mes = "Message";
var _Mess = "Messages";
var _Mi = "Minimum";
var _N = "Namespace";
var _NT = "NextToken";
var _Na = "Name";
var _Nam = "Names";
var _OA = "OwningAccount";
var _OAw = "OwningAccounts";
var _OB = "OrderBy";
var _OF = "OutputFormat";
var _OKA = "OKActions";
var _P = "Period";
var _PAD = "PutAnomalyDetector";
var _PCA = "PutCompositeAlarm";
var _PD = "PutDashboard";
var _PIR = "PutInsightRule";
var _PMA = "PutMetricAlarm";
var _PMD = "PutMetricData";
var _PMIR = "PutManagedInsightRules";
var _PMS = "PutMetricStream";
var _POAN = "ParentsOfAlarmName";
var _RA = "RecentlyActive";
var _RARN = "ResourceARN";
var _RAo = "RoleArn";
var _RD = "ReturnData";
var _RDu = "RuleDefinition";
var _RI = "ResourceId";
var _RN = "RuleNames";
var _RNu = "RuleName";
var _RS = "RuleState";
var _RT = "ResourceType";
var _S = "Stat";
var _SAS = "SetAlarmState";
var _SB = "ScanBy";
var _SC = "StatisticsConfigurations";
var _SCa = "SampleCount";
var _SCt = "StatusCode";
var _SD = "StartDate";
var _SMAD = "SingleMetricAnomalyDetector";
var _SMS = "StartMetricStreams";
var _SMSt = "StopMetricStreams";
var _SR = "StorageResolution";
var _SRD = "StateReasonData";
var _SRt = "StateReason";
var _ST = "StartTime";
var _STT = "StateTransitionedTimestamp";
var _SUT = "StateUpdatedTimestamp";
var _SV = "StateValue";
var _SVt = "StatisticValues";
var _Sc = "Schema";
var _Si = "Size";
var _St = "Statistic";
var _Sta = "Statistics";
var _Stat = "State";
var _Su = "Sum";
var _T = "Timezone";
var _TK = "TagKeys";
var _TMD = "TreatMissingData";
var _TMI = "ThresholdMetricId";
var _TN = "TemplateName";
var _TR = "TagResource";
var _Ta = "Tags";
var _Th = "Threshold";
var _Ti = "Timestamp";
var _Tim = "Timestamps";
var _U = "Unit";
var _UC = "UniqueContributors";
var _UR = "UntagResource";
var _V = "Version";
var _Va = "Value";
var _Val = "Values";
var _dVM = "dashboardValidationMessages";
var _e = "entry";
var _m = "member";
var _me = "message";
var parseBody = /* @__PURE__ */ __name((streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
  if (encoded.length) {
    const parser = new import_fast_xml_parser.XMLParser({
      attributeNamePrefix: "",
      htmlEntities: true,
      ignoreAttributes: false,
      ignoreDeclaration: true,
      parseTagValue: false,
      trimValues: false,
      tagValueProcessor: (_2, val) => val.trim() === "" && val.includes("\n") ? "" : void 0
    });
    parser.addEntity("#xD", "\r");
    parser.addEntity("#10", "\n");
    const parsedObj = parser.parse(encoded);
    const textNodeName = "#text";
    const key = Object.keys(parsedObj)[0];
    const parsedObjToReturn = parsedObj[key];
    if (parsedObjToReturn[textNodeName]) {
      parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
      delete parsedObjToReturn[textNodeName];
    }
    return (0, import_smithy_client.getValueFromTextNode)(parsedObjToReturn);
  }
  return {};
}), "parseBody");
var parseErrorBody = /* @__PURE__ */ __name(async (errorBody, context) => {
  const value = await parseBody(errorBody, context);
  if (value.Error) {
    value.Error.message = value.Error.message ?? value.Error.Message;
  }
  return value;
}, "parseErrorBody");
var buildFormUrlencodedString = /* @__PURE__ */ __name((formEntries) => Object.entries(formEntries).map(([key, value]) => (0, import_smithy_client.extendedEncodeURIComponent)(key) + "=" + (0, import_smithy_client.extendedEncodeURIComponent)(value)).join("&"), "buildFormUrlencodedString");
var loadQueryErrorCode = /* @__PURE__ */ __name((output, data) => {
  var _a;
  if (((_a = data.Error) == null ? void 0 : _a.Code) !== void 0) {
    return data.Error.Code;
  }
  if (output.statusCode == 404) {
    return "NotFound";
  }
}, "loadQueryErrorCode");

// src/commands/DeleteAlarmsCommand.ts
var _DeleteAlarmsCommand = class _DeleteAlarmsCommand 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("GraniteServiceVersion20100801", "DeleteAlarms", {}).n("CloudWatchClient", "DeleteAlarmsCommand").f(void 0, void 0).ser(se_DeleteAlarmsCommand).de(de_DeleteAlarmsCommand).build() {
};
__name(_DeleteAlarmsCommand, "DeleteAlarmsCommand");
var DeleteAlarmsCommand = _DeleteAlarmsCommand;

// src/commands/DeleteAnomalyDetectorCommand.ts




var _DeleteAnomalyDetectorCommand = class _DeleteAnomalyDetectorCommand 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("GraniteServiceVersion20100801", "DeleteAnomalyDetector", {}).n("CloudWatchClient", "DeleteAnomalyDetectorCommand").f(void 0, void 0).ser(se_DeleteAnomalyDetectorCommand).de(de_DeleteAnomalyDetectorCommand).build() {
};
__name(_DeleteAnomalyDetectorCommand, "DeleteAnomalyDetectorCommand");
var DeleteAnomalyDetectorCommand = _DeleteAnomalyDetectorCommand;

// src/commands/DeleteDashboardsCommand.ts




var _DeleteDashboardsCommand = class _DeleteDashboardsCommand 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("GraniteServiceVersion20100801", "DeleteDashboards", {}).n("CloudWatchClient", "DeleteDashboardsCommand").f(void 0, void 0).ser(se_DeleteDashboardsCommand).de(de_DeleteDashboardsCommand).build() {
};
__name(_DeleteDashboardsCommand, "DeleteDashboardsCommand");
var DeleteDashboardsCommand = _DeleteDashboardsCommand;

// src/commands/DeleteInsightRulesCommand.ts




var _DeleteInsightRulesCommand = class _DeleteInsightRulesCommand 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("GraniteServiceVersion20100801", "DeleteInsightRules", {}).n("CloudWatchClient", "DeleteInsightRulesCommand").f(void 0, void 0).ser(se_DeleteInsightRulesCommand).de(de_DeleteInsightRulesCommand).build() {
};
__name(_DeleteInsightRulesCommand, "DeleteInsightRulesCommand");
var DeleteInsightRulesCommand = _DeleteInsightRulesCommand;

// src/commands/DeleteMetricStreamCommand.ts




var _DeleteMetricStreamCommand = class _DeleteMetricStreamCommand 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("GraniteServiceVersion20100801", "DeleteMetricStream", {}).n("CloudWatchClient", "DeleteMetricStreamCommand").f(void 0, void 0).ser(se_DeleteMetricStreamCommand).de(de_DeleteMetricStreamCommand).build() {
};
__name(_DeleteMetricStreamCommand, "DeleteMetricStreamCommand");
var DeleteMetricStreamCommand = _DeleteMetricStreamCommand;

// src/commands/DescribeAlarmHistoryCommand.ts




var _DescribeAlarmHistoryCommand = class _DescribeAlarmHistoryCommand 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("GraniteServiceVersion20100801", "DescribeAlarmHistory", {}).n("CloudWatchClient", "DescribeAlarmHistoryCommand").f(void 0, void 0).ser(se_DescribeAlarmHistoryCommand).de(de_DescribeAlarmHistoryCommand).build() {
};
__name(_DescribeAlarmHistoryCommand, "DescribeAlarmHistoryCommand");
var DescribeAlarmHistoryCommand = _DescribeAlarmHistoryCommand;

// src/commands/DescribeAlarmsCommand.ts




var _DescribeAlarmsCommand = class _DescribeAlarmsCommand 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("GraniteServiceVersion20100801", "DescribeAlarms", {}).n("CloudWatchClient", "DescribeAlarmsCommand").f(void 0, void 0).ser(se_DescribeAlarmsCommand).de(de_DescribeAlarmsCommand).build() {
};
__name(_DescribeAlarmsCommand, "DescribeAlarmsCommand");
var DescribeAlarmsCommand = _DescribeAlarmsCommand;

// src/commands/DescribeAlarmsForMetricCommand.ts




var _DescribeAlarmsForMetricCommand = class _DescribeAlarmsForMetricCommand 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("GraniteServiceVersion20100801", "DescribeAlarmsForMetric", {}).n("CloudWatchClient", "DescribeAlarmsForMetricCommand").f(void 0, void 0).ser(se_DescribeAlarmsForMetricCommand).de(de_DescribeAlarmsForMetricCommand).build() {
};
__name(_DescribeAlarmsForMetricCommand, "DescribeAlarmsForMetricCommand");
var DescribeAlarmsForMetricCommand = _DescribeAlarmsForMetricCommand;

// src/commands/DescribeAnomalyDetectorsCommand.ts




var _DescribeAnomalyDetectorsCommand = class _DescribeAnomalyDetectorsCommand 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("GraniteServiceVersion20100801", "DescribeAnomalyDetectors", {}).n("CloudWatchClient", "DescribeAnomalyDetectorsCommand").f(void 0, void 0).ser(se_DescribeAnomalyDetectorsCommand).de(de_DescribeAnomalyDetectorsCommand).build() {
};
__name(_DescribeAnomalyDetectorsCommand, "DescribeAnomalyDetectorsCommand");
var DescribeAnomalyDetectorsCommand = _DescribeAnomalyDetectorsCommand;

// src/commands/DescribeInsightRulesCommand.ts




var _DescribeInsightRulesCommand = class _DescribeInsightRulesCommand 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("GraniteServiceVersion20100801", "DescribeInsightRules", {}).n("CloudWatchClient", "DescribeInsightRulesCommand").f(void 0, void 0).ser(se_DescribeInsightRulesCommand).de(de_DescribeInsightRulesCommand).build() {
};
__name(_DescribeInsightRulesCommand, "DescribeInsightRulesCommand");
var DescribeInsightRulesCommand = _DescribeInsightRulesCommand;

// src/commands/DisableAlarmActionsCommand.ts




var _DisableAlarmActionsCommand = class _DisableAlarmActionsCommand 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("GraniteServiceVersion20100801", "DisableAlarmActions", {}).n("CloudWatchClient", "DisableAlarmActionsCommand").f(void 0, void 0).ser(se_DisableAlarmActionsCommand).de(de_DisableAlarmActionsCommand).build() {
};
__name(_DisableAlarmActionsCommand, "DisableAlarmActionsCommand");
var DisableAlarmActionsCommand = _DisableAlarmActionsCommand;

// src/commands/DisableInsightRulesCommand.ts




var _DisableInsightRulesCommand = class _DisableInsightRulesCommand 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("GraniteServiceVersion20100801", "DisableInsightRules", {}).n("CloudWatchClient", "DisableInsightRulesCommand").f(void 0, void 0).ser(se_DisableInsightRulesCommand).de(de_DisableInsightRulesCommand).build() {
};
__name(_DisableInsightRulesCommand, "DisableInsightRulesCommand");
var DisableInsightRulesCommand = _DisableInsightRulesCommand;

// src/commands/EnableAlarmActionsCommand.ts




var _EnableAlarmActionsCommand = class _EnableAlarmActionsCommand 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("GraniteServiceVersion20100801", "EnableAlarmActions", {}).n("CloudWatchClient", "EnableAlarmActionsCommand").f(void 0, void 0).ser(se_EnableAlarmActionsCommand).de(de_EnableAlarmActionsCommand).build() {
};
__name(_EnableAlarmActionsCommand, "EnableAlarmActionsCommand");
var EnableAlarmActionsCommand = _EnableAlarmActionsCommand;

// src/commands/EnableInsightRulesCommand.ts




var _EnableInsightRulesCommand = class _EnableInsightRulesCommand 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("GraniteServiceVersion20100801", "EnableInsightRules", {}).n("CloudWatchClient", "EnableInsightRulesCommand").f(void 0, void 0).ser(se_EnableInsightRulesCommand).de(de_EnableInsightRulesCommand).build() {
};
__name(_EnableInsightRulesCommand, "EnableInsightRulesCommand");
var EnableInsightRulesCommand = _EnableInsightRulesCommand;

// src/commands/GetDashboardCommand.ts




var _GetDashboardCommand = class _GetDashboardCommand 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("GraniteServiceVersion20100801", "GetDashboard", {}).n("CloudWatchClient", "GetDashboardCommand").f(void 0, void 0).ser(se_GetDashboardCommand).de(de_GetDashboardCommand).build() {
};
__name(_GetDashboardCommand, "GetDashboardCommand");
var GetDashboardCommand = _GetDashboardCommand;

// src/commands/GetInsightRuleReportCommand.ts




var _GetInsightRuleReportCommand = class _GetInsightRuleReportCommand 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("GraniteServiceVersion20100801", "GetInsightRuleReport", {}).n("CloudWatchClient", "GetInsightRuleReportCommand").f(void 0, void 0).ser(se_GetInsightRuleReportCommand).de(de_GetInsightRuleReportCommand).build() {
};
__name(_GetInsightRuleReportCommand, "GetInsightRuleReportCommand");
var GetInsightRuleReportCommand = _GetInsightRuleReportCommand;

// src/commands/GetMetricDataCommand.ts




var _GetMetricDataCommand = class _GetMetricDataCommand 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("GraniteServiceVersion20100801", "GetMetricData", {}).n("CloudWatchClient", "GetMetricDataCommand").f(void 0, void 0).ser(se_GetMetricDataCommand).de(de_GetMetricDataCommand).build() {
};
__name(_GetMetricDataCommand, "GetMetricDataCommand");
var GetMetricDataCommand = _GetMetricDataCommand;

// src/commands/GetMetricStatisticsCommand.ts




var _GetMetricStatisticsCommand = class _GetMetricStatisticsCommand 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("GraniteServiceVersion20100801", "GetMetricStatistics", {}).n("CloudWatchClient", "GetMetricStatisticsCommand").f(void 0, void 0).ser(se_GetMetricStatisticsCommand).de(de_GetMetricStatisticsCommand).build() {
};
__name(_GetMetricStatisticsCommand, "GetMetricStatisticsCommand");
var GetMetricStatisticsCommand = _GetMetricStatisticsCommand;

// src/commands/GetMetricStreamCommand.ts




var _GetMetricStreamCommand = class _GetMetricStreamCommand 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("GraniteServiceVersion20100801", "GetMetricStream", {}).n("CloudWatchClient", "GetMetricStreamCommand").f(void 0, void 0).ser(se_GetMetricStreamCommand).de(de_GetMetricStreamCommand).build() {
};
__name(_GetMetricStreamCommand, "GetMetricStreamCommand");
var GetMetricStreamCommand = _GetMetricStreamCommand;

// src/commands/GetMetricWidgetImageCommand.ts




var _GetMetricWidgetImageCommand = class _GetMetricWidgetImageCommand 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("GraniteServiceVersion20100801", "GetMetricWidgetImage", {}).n("CloudWatchClient", "GetMetricWidgetImageCommand").f(void 0, void 0).ser(se_GetMetricWidgetImageCommand).de(de_GetMetricWidgetImageCommand).build() {
};
__name(_GetMetricWidgetImageCommand, "GetMetricWidgetImageCommand");
var GetMetricWidgetImageCommand = _GetMetricWidgetImageCommand;

// src/commands/ListDashboardsCommand.ts




var _ListDashboardsCommand = class _ListDashboardsCommand 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("GraniteServiceVersion20100801", "ListDashboards", {}).n("CloudWatchClient", "ListDashboardsCommand").f(void 0, void 0).ser(se_ListDashboardsCommand).de(de_ListDashboardsCommand).build() {
};
__name(_ListDashboardsCommand, "ListDashboardsCommand");
var ListDashboardsCommand = _ListDashboardsCommand;

// src/commands/ListManagedInsightRulesCommand.ts




var _ListManagedInsightRulesCommand = class _ListManagedInsightRulesCommand 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("GraniteServiceVersion20100801", "ListManagedInsightRules", {}).n("CloudWatchClient", "ListManagedInsightRulesCommand").f(void 0, void 0).ser(se_ListManagedInsightRulesCommand).de(de_ListManagedInsightRulesCommand).build() {
};
__name(_ListManagedInsightRulesCommand, "ListManagedInsightRulesCommand");
var ListManagedInsightRulesCommand = _ListManagedInsightRulesCommand;

// src/commands/ListMetricsCommand.ts




var _ListMetricsCommand = class _ListMetricsCommand 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("GraniteServiceVersion20100801", "ListMetrics", {}).n("CloudWatchClient", "ListMetricsCommand").f(void 0, void 0).ser(se_ListMetricsCommand).de(de_ListMetricsCommand).build() {
};
__name(_ListMetricsCommand, "ListMetricsCommand");
var ListMetricsCommand = _ListMetricsCommand;

// src/commands/ListMetricStreamsCommand.ts




var _ListMetricStreamsCommand = class _ListMetricStreamsCommand 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("GraniteServiceVersion20100801", "ListMetricStreams", {}).n("CloudWatchClient", "ListMetricStreamsCommand").f(void 0, void 0).ser(se_ListMetricStreamsCommand).de(de_ListMetricStreamsCommand).build() {
};
__name(_ListMetricStreamsCommand, "ListMetricStreamsCommand");
var ListMetricStreamsCommand = _ListMetricStreamsCommand;

// src/commands/ListTagsForResourceCommand.ts




var _ListTagsForResourceCommand = class _ListTagsForResourceCommand extends import_smithy_client.Command.classBuilder().ep({
  ...commonParams
}).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("GraniteServiceVersion20100801", "ListTagsForResource", {}).n("CloudWatchClient", "ListTagsForResourceCommand").f(void 0, void 0).ser(se_ListTagsForResourceCommand).de(de_ListTagsForResourceCommand).build() {
};
__name(_ListTagsForResourceCommand, "ListTagsForResourceCommand");
var ListTagsForResourceCommand = _ListTagsForResourceCommand;

// src/commands/PutAnomalyDetectorCommand.ts




var _PutAnomalyDetectorCommand = class _PutAnomalyDetectorCommand 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("GraniteServiceVersion20100801", "PutAnomalyDetector", {}).n("CloudWatchClient", "PutAnomalyDetectorCommand").f(void 0, void 0).ser(se_PutAnomalyDetectorCommand).de(de_PutAnomalyDetectorCommand).build() {
};
__name(_PutAnomalyDetectorCommand, "PutAnomalyDetectorCommand");
var PutAnomalyDetectorCommand = _PutAnomalyDetectorCommand;

// src/commands/PutCompositeAlarmCommand.ts




var _PutCompositeAlarmCommand = class _PutCompositeAlarmCommand 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("GraniteServiceVersion20100801", "PutCompositeAlarm", {}).n("CloudWatchClient", "PutCompositeAlarmCommand").f(void 0, void 0).ser(se_PutCompositeAlarmCommand).de(de_PutCompositeAlarmCommand).build() {
};
__name(_PutCompositeAlarmCommand, "PutCompositeAlarmCommand");
var PutCompositeAlarmCommand = _PutCompositeAlarmCommand;

// src/commands/PutDashboardCommand.ts




var _PutDashboardCommand = class _PutDashboardCommand 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("GraniteServiceVersion20100801", "PutDashboard", {}).n("CloudWatchClient", "PutDashboardCommand").f(void 0, void 0).ser(se_PutDashboardCommand).de(de_PutDashboardCommand).build() {
};
__name(_PutDashboardCommand, "PutDashboardCommand");
var PutDashboardCommand = _PutDashboardCommand;

// src/commands/PutInsightRuleCommand.ts




var _PutInsightRuleCommand = class _PutInsightRuleCommand 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("GraniteServiceVersion20100801", "PutInsightRule", {}).n("CloudWatchClient", "PutInsightRuleCommand").f(void 0, void 0).ser(se_PutInsightRuleCommand).de(de_PutInsightRuleCommand).build() {
};
__name(_PutInsightRuleCommand, "PutInsightRuleCommand");
var PutInsightRuleCommand = _PutInsightRuleCommand;

// src/commands/PutManagedInsightRulesCommand.ts




var _PutManagedInsightRulesCommand = class _PutManagedInsightRulesCommand 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("GraniteServiceVersion20100801", "PutManagedInsightRules", {}).n("CloudWatchClient", "PutManagedInsightRulesCommand").f(void 0, void 0).ser(se_PutManagedInsightRulesCommand).de(de_PutManagedInsightRulesCommand).build() {
};
__name(_PutManagedInsightRulesCommand, "PutManagedInsightRulesCommand");
var PutManagedInsightRulesCommand = _PutManagedInsightRulesCommand;

// src/commands/PutMetricAlarmCommand.ts




var _PutMetricAlarmCommand = class _PutMetricAlarmCommand 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("GraniteServiceVersion20100801", "PutMetricAlarm", {}).n("CloudWatchClient", "PutMetricAlarmCommand").f(void 0, void 0).ser(se_PutMetricAlarmCommand).de(de_PutMetricAlarmCommand).build() {
};
__name(_PutMetricAlarmCommand, "PutMetricAlarmCommand");
var PutMetricAlarmCommand = _PutMetricAlarmCommand;

// src/commands/PutMetricDataCommand.ts





var _PutMetricDataCommand = class _PutMetricDataCommand 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()),
    (0, import_middleware_compression.getCompressionPlugin)(config, { encodings: ["gzip"] })
  ];
}).s("GraniteServiceVersion20100801", "PutMetricData", {}).n("CloudWatchClient", "PutMetricDataCommand").f(void 0, void 0).ser(se_PutMetricDataCommand).de(de_PutMetricDataCommand).build() {
};
__name(_PutMetricDataCommand, "PutMetricDataCommand");
var PutMetricDataCommand = _PutMetricDataCommand;

// src/commands/PutMetricStreamCommand.ts




var _PutMetricStreamCommand = class _PutMetricStreamCommand 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("GraniteServiceVersion20100801", "PutMetricStream", {}).n("CloudWatchClient", "PutMetricStreamCommand").f(void 0, void 0).ser(se_PutMetricStreamCommand).de(de_PutMetricStreamCommand).build() {
};
__name(_PutMetricStreamCommand, "PutMetricStreamCommand");
var PutMetricStreamCommand = _PutMetricStreamCommand;

// src/commands/SetAlarmStateCommand.ts




var _SetAlarmStateCommand = class _SetAlarmStateCommand 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("GraniteServiceVersion20100801", "SetAlarmState", {}).n("CloudWatchClient", "SetAlarmStateCommand").f(void 0, void 0).ser(se_SetAlarmStateCommand).de(de_SetAlarmStateCommand).build() {
};
__name(_SetAlarmStateCommand, "SetAlarmStateCommand");
var SetAlarmStateCommand = _SetAlarmStateCommand;

// src/commands/StartMetricStreamsCommand.ts




var _StartMetricStreamsCommand = class _StartMetricStreamsCommand 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("GraniteServiceVersion20100801", "StartMetricStreams", {}).n("CloudWatchClient", "StartMetricStreamsCommand").f(void 0, void 0).ser(se_StartMetricStreamsCommand).de(de_StartMetricStreamsCommand).build() {
};
__name(_StartMetricStreamsCommand, "StartMetricStreamsCommand");
var StartMetricStreamsCommand = _StartMetricStreamsCommand;

// src/commands/StopMetricStreamsCommand.ts




var _StopMetricStreamsCommand = class _StopMetricStreamsCommand 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("GraniteServiceVersion20100801", "StopMetricStreams", {}).n("CloudWatchClient", "StopMetricStreamsCommand").f(void 0, void 0).ser(se_StopMetricStreamsCommand).de(de_StopMetricStreamsCommand).build() {
};
__name(_StopMetricStreamsCommand, "StopMetricStreamsCommand");
var StopMetricStreamsCommand = _StopMetricStreamsCommand;

// src/commands/TagResourceCommand.ts




var _TagResourceCommand = class _TagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
  ...commonParams
}).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("GraniteServiceVersion20100801", "TagResource", {}).n("CloudWatchClient", "TagResourceCommand").f(void 0, void 0).ser(se_TagResourceCommand).de(de_TagResourceCommand).build() {
};
__name(_TagResourceCommand, "TagResourceCommand");
var TagResourceCommand = _TagResourceCommand;

// src/commands/UntagResourceCommand.ts




var _UntagResourceCommand = class _UntagResourceCommand extends import_smithy_client.Command.classBuilder().ep({
  ...commonParams
}).m(function(Command, cs, config, o) {
  return [
    (0, import_middleware_serde.getSerdePlugin)(config, this.serialize, this.deserialize),
    (0, import_middleware_endpoint.getEndpointPlugin)(config, Command.getEndpointParameterInstructions())
  ];
}).s("GraniteServiceVersion20100801", "UntagResource", {}).n("CloudWatchClient", "UntagResourceCommand").f(void 0, void 0).ser(se_UntagResourceCommand).de(de_UntagResourceCommand).build() {
};
__name(_UntagResourceCommand, "UntagResourceCommand");
var UntagResourceCommand = _UntagResourceCommand;

// src/CloudWatch.ts
var commands = {
  DeleteAlarmsCommand,
  DeleteAnomalyDetectorCommand,
  DeleteDashboardsCommand,
  DeleteInsightRulesCommand,
  DeleteMetricStreamCommand,
  DescribeAlarmHistoryCommand,
  DescribeAlarmsCommand,
  DescribeAlarmsForMetricCommand,
  DescribeAnomalyDetectorsCommand,
  DescribeInsightRulesCommand,
  DisableAlarmActionsCommand,
  DisableInsightRulesCommand,
  EnableAlarmActionsCommand,
  EnableInsightRulesCommand,
  GetDashboardCommand,
  GetInsightRuleReportCommand,
  GetMetricDataCommand,
  GetMetricStatisticsCommand,
  GetMetricStreamCommand,
  GetMetricWidgetImageCommand,
  ListDashboardsCommand,
  ListManagedInsightRulesCommand,
  ListMetricsCommand,
  ListMetricStreamsCommand,
  ListTagsForResourceCommand,
  PutAnomalyDetectorCommand,
  PutCompositeAlarmCommand,
  PutDashboardCommand,
  PutInsightRuleCommand,
  PutManagedInsightRulesCommand,
  PutMetricAlarmCommand,
  PutMetricDataCommand,
  PutMetricStreamCommand,
  SetAlarmStateCommand,
  StartMetricStreamsCommand,
  StopMetricStreamsCommand,
  TagResourceCommand,
  UntagResourceCommand
};
var _CloudWatch = class _CloudWatch extends CloudWatchClient {
};
__name(_CloudWatch, "CloudWatch");
var CloudWatch = _CloudWatch;
(0, import_smithy_client.createAggregatedClient)(commands, CloudWatch);

// src/pagination/DescribeAlarmHistoryPaginator.ts

var paginateDescribeAlarmHistory = (0, import_core.createPaginator)(CloudWatchClient, DescribeAlarmHistoryCommand, "NextToken", "NextToken", "MaxRecords");

// src/pagination/DescribeAlarmsPaginator.ts

var paginateDescribeAlarms = (0, import_core.createPaginator)(CloudWatchClient, DescribeAlarmsCommand, "NextToken", "NextToken", "MaxRecords");

// src/pagination/DescribeAnomalyDetectorsPaginator.ts

var paginateDescribeAnomalyDetectors = (0, import_core.createPaginator)(CloudWatchClient, DescribeAnomalyDetectorsCommand, "NextToken", "NextToken", "MaxResults");

// src/pagination/DescribeInsightRulesPaginator.ts

var paginateDescribeInsightRules = (0, import_core.createPaginator)(CloudWatchClient, DescribeInsightRulesCommand, "NextToken", "NextToken", "MaxResults");

// src/pagination/GetMetricDataPaginator.ts

var paginateGetMetricData = (0, import_core.createPaginator)(CloudWatchClient, GetMetricDataCommand, "NextToken", "NextToken", "MaxDatapoints");

// src/pagination/ListDashboardsPaginator.ts

var paginateListDashboards = (0, import_core.createPaginator)(CloudWatchClient, ListDashboardsCommand, "NextToken", "NextToken", "");

// src/pagination/ListManagedInsightRulesPaginator.ts

var paginateListManagedInsightRules = (0, import_core.createPaginator)(CloudWatchClient, ListManagedInsightRulesCommand, "NextToken", "NextToken", "MaxResults");

// src/pagination/ListMetricStreamsPaginator.ts

var paginateListMetricStreams = (0, import_core.createPaginator)(CloudWatchClient, ListMetricStreamsCommand, "NextToken", "NextToken", "MaxResults");

// src/pagination/ListMetricsPaginator.ts

var paginateListMetrics = (0, import_core.createPaginator)(CloudWatchClient, ListMetricsCommand, "NextToken", "NextToken", "");

// src/waiters/waitForAlarmExists.ts
var import_util_waiter = require("@smithy/util-waiter");
var checkState = /* @__PURE__ */ __name(async (client, input) => {
  let reason;
  try {
    const result = await client.send(new DescribeAlarmsCommand(input));
    reason = result;
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        const flat_1 = [].concat(...result.MetricAlarms);
        return flat_1.length > 0;
      }, "returnComparator");
      if (returnComparator() == true) {
        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
      }
    } catch (e) {
    }
  } catch (exception) {
    reason = exception;
  }
  return { state: import_util_waiter.WaiterState.RETRY, reason };
}, "checkState");
var waitForAlarmExists = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
}, "waitForAlarmExists");
var waitUntilAlarmExists = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState);
  return (0, import_util_waiter.checkExceptions)(result);
}, "waitUntilAlarmExists");

// src/waiters/waitForCompositeAlarmExists.ts

var checkState2 = /* @__PURE__ */ __name(async (client, input) => {
  let reason;
  try {
    const result = await client.send(new DescribeAlarmsCommand(input));
    reason = result;
    try {
      const returnComparator = /* @__PURE__ */ __name(() => {
        const flat_1 = [].concat(...result.CompositeAlarms);
        return flat_1.length > 0;
      }, "returnComparator");
      if (returnComparator() == true) {
        return { state: import_util_waiter.WaiterState.SUCCESS, reason };
      }
    } catch (e) {
    }
  } catch (exception) {
    reason = exception;
  }
  return { state: import_util_waiter.WaiterState.RETRY, reason };
}, "checkState");
var waitForCompositeAlarmExists = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
  return (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
}, "waitForCompositeAlarmExists");
var waitUntilCompositeAlarmExists = /* @__PURE__ */ __name(async (params, input) => {
  const serviceDefaults = { minDelay: 5, maxDelay: 120 };
  const result = await (0, import_util_waiter.createWaiter)({ ...serviceDefaults, ...params }, input, checkState2);
  return (0, import_util_waiter.checkExceptions)(result);
}, "waitUntilCompositeAlarmExists");

// src/index.ts
var import_util_endpoints = require("@aws-sdk/util-endpoints");
// Annotate the CommonJS export names for ESM import in node:

0 && (module.exports = {
  CloudWatchServiceException,
  __Client,
  CloudWatchClient,
  CloudWatch,
  $Command,
  DeleteAlarmsCommand,
  DeleteAnomalyDetectorCommand,
  DeleteDashboardsCommand,
  DeleteInsightRulesCommand,
  DeleteMetricStreamCommand,
  DescribeAlarmHistoryCommand,
  DescribeAlarmsCommand,
  DescribeAlarmsForMetricCommand,
  DescribeAnomalyDetectorsCommand,
  DescribeInsightRulesCommand,
  DisableAlarmActionsCommand,
  DisableInsightRulesCommand,
  EnableAlarmActionsCommand,
  EnableInsightRulesCommand,
  GetDashboardCommand,
  GetInsightRuleReportCommand,
  GetMetricDataCommand,
  GetMetricStatisticsCommand,
  GetMetricStreamCommand,
  GetMetricWidgetImageCommand,
  ListDashboardsCommand,
  ListManagedInsightRulesCommand,
  ListMetricStreamsCommand,
  ListMetricsCommand,
  ListTagsForResourceCommand,
  PutAnomalyDetectorCommand,
  PutCompositeAlarmCommand,
  PutDashboardCommand,
  PutInsightRuleCommand,
  PutManagedInsightRulesCommand,
  PutMetricAlarmCommand,
  PutMetricDataCommand,
  PutMetricStreamCommand,
  SetAlarmStateCommand,
  StartMetricStreamsCommand,
  StopMetricStreamsCommand,
  TagResourceCommand,
  UntagResourceCommand,
  paginateDescribeAlarmHistory,
  paginateDescribeAlarms,
  paginateDescribeAnomalyDetectors,
  paginateDescribeInsightRules,
  paginateGetMetricData,
  paginateListDashboards,
  paginateListManagedInsightRules,
  paginateListMetricStreams,
  paginateListMetrics,
  waitForAlarmExists,
  waitUntilAlarmExists,
  waitForCompositeAlarmExists,
  waitUntilCompositeAlarmExists,
  ActionsSuppressedBy,
  AlarmType,
  HistoryItemType,
  StandardUnit,
  AnomalyDetectorStateValue,
  AnomalyDetectorType,
  ComparisonOperator,
  StateValue,
  ConcurrentModificationException,
  DashboardInvalidInputError,
  DashboardNotFoundError,
  ResourceNotFound,
  InternalServiceFault,
  InvalidParameterCombinationException,
  InvalidParameterValueException,
  MissingRequiredParameterException,
  ResourceNotFoundException,
  ScanBy,
  InvalidNextToken,
  EvaluationState,
  Statistic,
  LimitExceededException,
  StatusCode,
  MetricStreamOutputFormat,
  RecentlyActive,
  LimitExceededFault,
  InvalidFormatFault
});

