@aws-sdk/client-cloudwatch 3.1074.0 → 3.1076.0

package/dist-cjs/index.js

@@ -1,22 +1,58 @@
-var __exportStar = (m, e) => { Object.assign(e, m); };
-const { getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
+const { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require("@aws-sdk/core/client");
 const { getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, createPaginator } = require("@smithy/core");
-const { getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
+const { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, Command, createWaiter, checkExceptions, WaiterState, createAggregatedClient } = require("@smithy/core/client");
 exports.$Command = Command;
 exports.__Client = Client;
-const { resolveRegionConfig } = require("@smithy/core/config");
-const { resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
-const { getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
-const { resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
-const { getSchemaSerdePlugin } = require("@smithy/core/schema");
-const { resolveCompressionConfig, getCompressionPlugin } = require("@smithy/middleware-compression");
-const { resolveHttpAuthSchemeConfig, defaultCloudWatchHttpAuthSchemeParametersProvider } = require("./auth/httpAuthSchemeProvider");
-const { getRuntimeConfig } = require("./runtimeConfig");
-const { AssociateDatasetKmsKey$, DeleteAlarmMuteRule$, DeleteAlarms$, DeleteAnomalyDetector$, DeleteDashboards$, DeleteInsightRules$, DeleteMetricStream$, DescribeAlarmContributors$, DescribeAlarmHistory$, DescribeAlarms$, DescribeAlarmsForMetric$, DescribeAnomalyDetectors$, DescribeInsightRules$, DisableAlarmActions$, DisableInsightRules$, DisassociateDatasetKmsKey$, EnableAlarmActions$, EnableInsightRules$, GetAlarmMuteRule$, GetDashboard$, GetDataset$, GetInsightRuleReport$, GetMetricData$, GetMetricStatistics$, GetMetricStream$, GetMetricWidgetImage$, GetOTelEnrichment$, ListAlarmMuteRules$, ListDashboards$, ListManagedInsightRules$, ListMetrics$, ListMetricStreams$, ListTagsForResource$, PutAlarmMuteRule$, PutAnomalyDetector$, PutCompositeAlarm$, PutDashboard$, PutInsightRule$, PutManagedInsightRules$, PutMetricAlarm$, PutMetricData$, PutMetricStream$, SetAlarmState$, StartMetricStreams$, StartOTelEnrichment$, StopMetricStreams$, StopOTelEnrichment$, TagResource$, UntagResource$ } = require("./schemas/schemas_0");
-__exportStar(require("./schemas/schemas_0"), exports);
-__exportStar(require("./models/errors"), exports);
-const { CloudWatchServiceException } = require("./models/CloudWatchServiceException");
-exports.CloudWatchServiceException = CloudWatchServiceException;
+const { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require("@smithy/core/config");
+const { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require("@smithy/core/endpoints");
+const { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require("@smithy/core/protocols");
+const { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require("@smithy/core/retry");
+const { TypeRegistry, getSchemaSerdePlugin } = require("@smithy/core/schema");
+const { NODE_REQUEST_MIN_COMPRESSION_SIZE_BYTES_CONFIG_OPTIONS, NODE_DISABLE_REQUEST_COMPRESSION_CONFIG_OPTIONS, resolveCompressionConfig, getCompressionPlugin } = require("@smithy/middleware-compression");
+const { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require("@aws-sdk/core/httpAuthSchemes");
+const { defaultProvider } = require("@aws-sdk/credential-provider-node");
+const { toUtf8, fromUtf8, toBase64, fromBase64, Hash, calculateBodyLength } = require("@smithy/core/serde");
+const { streamCollector, NodeHttpHandler } = require("@smithy/node-http-handler");
+const { AwsJson1_0Protocol } = require("@aws-sdk/core/protocols");
+
+const defaultCloudWatchHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    return {
+        operation: getSmithyContext(context).operation,
+        region: await normalizeProvider(config.region)() || (() => {
+            throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
+        })(),
+    };
+};
+function createAwsAuthSigv4HttpAuthOption(authParameters) {
+    return {
+        schemeId: "aws.auth#sigv4",
+        signingProperties: {
+            name: "monitoring",
+            region: authParameters.region,
+        },
+        propertiesExtractor: (config, context) => ({
+            signingProperties: {
+                config,
+                context,
+            },
+        }),
+    };
+}
+const defaultCloudWatchHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        default: {
+            options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
+        }
+    }
+    return options;
+};
+const resolveHttpAuthSchemeConfig = (config) => {
+    const config_0 = resolveAwsSdkSigV4Config(config);
+    return Object.assign(config_0, {
+        authSchemePreference: normalizeProvider(config.authSchemePreference ?? []),
+    });
+};
 
 const resolveClientEndpointParameters = (options) => {
     return Object.assign(options, {
@@ -32,6 +68,1859 @@ const commonParams = {
     UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
 };
 
+var version = "3.1075.0";
+var packageInfo = {
+	version: version};
+
+const k = "ref";
+const a = -1, b = true, c = "isSet", d = "PartitionResult", e = "booleanEquals", f = "getAttr", g = { [k]: "Endpoint" }, h = { [k]: d }, i = {}, j = [{ [k]: "Region" }];
+const _data = {
+    conditions: [
+        [c, [g]],
+        [c, j],
+        ["aws.partition", j, d],
+        [e, [{ [k]: "UseFIPS" }, b]],
+        [e, [{ [k]: "UseDualStack" }, b]],
+        ["stringEquals", [{ fn: f, argv: [h, "name"] }, "aws-us-gov"]],
+        [e, [{ fn: f, argv: [h, "supportsFIPS"] }, b]],
+        [e, [{ fn: f, argv: [h, "supportsDualStack"] }, b]]
+    ],
+    results: [
+        [a],
+        [a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
+        [a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
+        [g, i],
+        ["https://monitoring.{Region}.{PartitionResult#dnsSuffix}", i],
+        ["https://monitoring.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        ["https://monitoring-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
+        [a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
+        ["https://monitoring-fips.{Region}.{PartitionResult#dnsSuffix}", i],
+        [a, "FIPS is enabled but this partition does not support FIPS"],
+        [a, "DualStack is enabled but this partition does not support DualStack"],
+        [a, "Invalid Configuration: Missing Region"]
+    ]
+};
+const root = 2;
+const r = 100_000_000;
+const nodes = new Int32Array([
+    -1, 1, -1,
+    0, 14, 3,
+    1, 4, r + 11,
+    2, 5, r + 11,
+    3, 8, 6,
+    4, 7, r + 4,
+    7, r + 5, r + 10,
+    4, 11, 9,
+    5, r + 4, 10,
+    6, r + 8, r + 9,
+    5, r + 5, 12,
+    6, 13, r + 7,
+    7, r + 6, r + 7,
+    3, r + 1, 15,
+    4, r + 2, r + 3,
+]);
+const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
+
+const cache = new EndpointCache({
+    size: 50,
+    params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"],
+});
+const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => decideEndpoint(bdd, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};
+customEndpointFunctions.aws = awsEndpointFunctions;
+
+class CloudWatchServiceException extends ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, CloudWatchServiceException.prototype);
+    }
+}
+
+class ConflictException extends CloudWatchServiceException {
+    name = "ConflictException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConflictException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class KmsAccessDeniedException extends CloudWatchServiceException {
+    name = "KmsAccessDeniedException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "KmsAccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KmsAccessDeniedException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class KmsKeyDisabledException extends CloudWatchServiceException {
+    name = "KmsKeyDisabledException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "KmsKeyDisabledException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KmsKeyDisabledException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class KmsKeyNotFoundException extends CloudWatchServiceException {
+    name = "KmsKeyNotFoundException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "KmsKeyNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, KmsKeyNotFoundException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class ResourceNotFoundException extends CloudWatchServiceException {
+    name = "ResourceNotFoundException";
+    $fault = "client";
+    ResourceType;
+    ResourceId;
+    Message;
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+        this.ResourceType = opts.ResourceType;
+        this.ResourceId = opts.ResourceId;
+        this.Message = opts.Message;
+    }
+}
+class ConcurrentModificationException extends CloudWatchServiceException {
+    name = "ConcurrentModificationException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "ConcurrentModificationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ConcurrentModificationException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class DashboardInvalidInputError extends CloudWatchServiceException {
+    name = "DashboardInvalidInputError";
+    $fault = "client";
+    dashboardValidationMessages;
+    constructor(opts) {
+        super({
+            name: "DashboardInvalidInputError",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DashboardInvalidInputError.prototype);
+        this.dashboardValidationMessages = opts.dashboardValidationMessages;
+    }
+}
+class DashboardNotFoundError extends CloudWatchServiceException {
+    name = "DashboardNotFoundError";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "DashboardNotFoundError",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, DashboardNotFoundError.prototype);
+    }
+}
+class ResourceConflict extends CloudWatchServiceException {
+    name = "ResourceConflict";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceConflict",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceConflict.prototype);
+    }
+}
+class ResourceNotFound extends CloudWatchServiceException {
+    name = "ResourceNotFound";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ResourceNotFound",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, ResourceNotFound.prototype);
+    }
+}
+class InternalServiceFault extends CloudWatchServiceException {
+    name = "InternalServiceFault";
+    $fault = "server";
+    Message;
+    constructor(opts) {
+        super({
+            name: "InternalServiceFault",
+            $fault: "server",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InternalServiceFault.prototype);
+        this.Message = opts.Message;
+    }
+}
+class InvalidParameterCombinationException extends CloudWatchServiceException {
+    name = "InvalidParameterCombinationException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidParameterCombinationException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidParameterCombinationException.prototype);
+    }
+}
+class InvalidParameterValueException extends CloudWatchServiceException {
+    name = "InvalidParameterValueException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidParameterValueException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidParameterValueException.prototype);
+    }
+}
+class MissingRequiredParameterException extends CloudWatchServiceException {
+    name = "MissingRequiredParameterException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "MissingRequiredParameterException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, MissingRequiredParameterException.prototype);
+    }
+}
+class InvalidNextToken extends CloudWatchServiceException {
+    name = "InvalidNextToken";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidNextToken",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidNextToken.prototype);
+    }
+}
+class LimitExceededException extends CloudWatchServiceException {
+    name = "LimitExceededException";
+    $fault = "client";
+    Message;
+    constructor(opts) {
+        super({
+            name: "LimitExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LimitExceededException.prototype);
+        this.Message = opts.Message;
+    }
+}
+class LimitExceededFault extends CloudWatchServiceException {
+    name = "LimitExceededFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "LimitExceededFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, LimitExceededFault.prototype);
+    }
+}
+class InvalidFormatFault extends CloudWatchServiceException {
+    name = "InvalidFormatFault";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "InvalidFormatFault",
+            $fault: "client",
+            ...opts,
+        });
+        Object.setPrototypeOf(this, InvalidFormatFault.prototype);
+    }
+}
+
+const _A = "Average";
+const _AA = "AlarmActions";
+const _AAV = "ApproximateAggregateValue";
+const _AAl = "AlarmArn";
+const _AC = "AlarmContributor";
+const _ACA = "AlarmContributorAttributes";
+const _ACI = "AlarmContributorId";
+const _ACUT = "AlarmConfigurationUpdatedTimestamp";
+const _ACl = "AlarmContributors";
+const _AD = "AnomalyDetector";
+const _ADC = "AnomalyDetectorConfiguration";
+const _ADETR = "AnomalyDetectorExcludedTimeRanges";
+const _ADKK = "AssociateDatasetKmsKey";
+const _ADKKI = "AssociateDatasetKmsKeyInput";
+const _ADKKO = "AssociateDatasetKmsKeyOutput";
+const _ADT = "AnomalyDetectorTypes";
+const _ADl = "AlarmDescription";
+const _ADn = "AnomalyDetectors";
+const _AE = "ActionsEnabled";
+const _AEg = "AggregationExpression";
+const _AHI = "AlarmHistoryItem";
+const _AHIl = "AlarmHistoryItems";
+const _AI = "AccountId";
+const _ALLC = "ActionLogLineCount";
+const _ALLRA = "ActionLogLineRoleArn";
+const _AMRA = "AlarmMuteRuleArn";
+const _AMRN = "AlarmMuteRuleName";
+const _AMRS = "AlarmMuteRuleSummary";
+const _AMRSl = "AlarmMuteRuleSummaries";
+const _AN = "AlarmName";
+const _ANP = "AlarmNamePrefix";
+const _ANl = "AlarmNames";
+const _AOTL = "ApplyOnTransformedLogs";
+const _AP = "ActionPrefix";
+const _APQLC = "AlarmPromQLCriteria";
+const _AR = "AlarmRule";
+const _AS = "ActionsSuppressor";
+const _ASB = "ActionsSuppressedBy";
+const _ASEP = "ActionsSuppressorExtensionPeriod";
+const _ASR = "ActionsSuppressedReason";
+const _ASWP = "ActionsSuppressorWaitPeriod";
+const _ASd = "AdditionalStatistics";
+const _ASg = "AggregationStatistic";
+const _AT = "AlarmType";
+const _ATl = "AlarmTypes";
+const _AUC = "ApproximateUniqueCount";
+const _AV = "AggregateValue";
+const _AVp = "ApproximateValue";
+const _Ar = "Arn";
+const _At = "Attributes";
+const _BF = "BatchFailures";
+const _C = "Configuration";
+const _CA = "ContributorAttributes";
+const _CAo = "CompositeAlarm";
+const _CAom = "CompositeAlarms";
+const _CD = "CreationDate";
+const _CE = "ConflictException";
+const _CI = "ContributorId";
+const _CME = "ConcurrentModificationException";
+const _CO = "ComparisonOperator";
+const _COAN = "ChildrenOfAlarmName";
+const _Co = "Contributors";
+const _Cod = "Code";
+const _Cou = "Counts";
+const _D = "Dimensions";
+const _DA = "DashboardArn";
+const _DAA = "DisableAlarmActions";
+const _DAAI = "DisableAlarmActionsInput";
+const _DAC = "DescribeAlarmContributors";
+const _DACI = "DescribeAlarmContributorsInput";
+const _DACO = "DescribeAlarmContributorsOutput";
+const _DAD = "DeleteAnomalyDetector";
+const _DADI = "DeleteAnomalyDetectorInput";
+const _DADIe = "DescribeAnomalyDetectorsInput";
+const _DADO = "DeleteAnomalyDetectorOutput";
+const _DADOe = "DescribeAnomalyDetectorsOutput";
+const _DADe = "DescribeAnomalyDetectors";
+const _DAFM = "DescribeAlarmsForMetric";
+const _DAFMI = "DescribeAlarmsForMetricInput";
+const _DAFMO = "DescribeAlarmsForMetricOutput";
+const _DAH = "DescribeAlarmHistory";
+const _DAHI = "DescribeAlarmHistoryInput";
+const _DAHO = "DescribeAlarmHistoryOutput";
+const _DAI = "DeleteAlarmsInput";
+const _DAIe = "DescribeAlarmsInput";
+const _DAMR = "DeleteAlarmMuteRule";
+const _DAMRI = "DeleteAlarmMuteRuleInput";
+const _DAO = "DescribeAlarmsOutput";
+const _DAe = "DeleteAlarms";
+const _DAes = "DescribeAlarms";
+const _DB = "DashboardBody";
+const _DD = "DeleteDashboards";
+const _DDI = "DeleteDashboardsInput";
+const _DDKK = "DisassociateDatasetKmsKey";
+const _DDKKI = "DisassociateDatasetKmsKeyInput";
+const _DDKKO = "DisassociateDatasetKmsKeyOutput";
+const _DDO = "DeleteDashboardsOutput";
+const _DE = "DashboardEntry";
+const _DEa = "DashboardEntries";
+const _DF = "DimensionFilter";
+const _DFi = "DimensionFilters";
+const _DI = "DatasetIdentifier";
+const _DIIE = "DashboardInvalidInputError";
+const _DIR = "DeleteInsightRules";
+const _DIRI = "DeleteInsightRulesInput";
+const _DIRIe = "DescribeInsightRulesInput";
+const _DIRIi = "DisableInsightRulesInput";
+const _DIRO = "DeleteInsightRulesOutput";
+const _DIROe = "DescribeInsightRulesOutput";
+const _DIROi = "DisableInsightRulesOutput";
+const _DIRe = "DescribeInsightRules";
+const _DIRi = "DisableInsightRules";
+const _DIa = "DatasetId";
+const _DMS = "DeleteMetricStream";
+const _DMSI = "DeleteMetricStreamInput";
+const _DMSO = "DeleteMetricStreamOutput";
+const _DN = "DashboardName";
+const _DNFE = "DashboardNotFoundError";
+const _DNP = "DashboardNamePrefix";
+const _DNa = "DashboardNames";
+const _DP = "DataPath";
+const _DTA = "DatapointsToAlarm";
+const _DVM = "DashboardValidationMessage";
+const _DVMa = "DashboardValidationMessages";
+const _Da = "Datapoint";
+const _Dat = "Datapoints";
+const _De = "Description";
+const _Def = "Definition";
+const _Di = "Dimension";
+const _Du = "Duration";
+const _E = "Entity";
+const _EAA = "EnableAlarmActions";
+const _EAAI = "EnableAlarmActionsInput";
+const _EC = "EvaluationCriteria";
+const _ED = "ExpireDate";
+const _EDn = "EndDate";
+const _EF = "ExcludeFilters";
+const _EI = "EvaluationInterval";
+const _EIR = "EnableInsightRules";
+const _EIRI = "EnableInsightRulesInput";
+const _EIRO = "EnableInsightRulesOutput";
+const _ELSCP = "EvaluateLowSampleCountPercentile";
+const _EMD = "EntityMetricData";
+const _EMDL = "EntityMetricDataList";
+const _EP = "EvaluationPeriods";
+const _ES = "ExtendedStatistics";
+const _ESv = "EvaluationState";
+const _ESx = "ExtendedStatistic";
+const _ET = "EndTime";
+const _ETO = "EndTimeOffset";
+const _ETR = "ExcludedTimeRanges";
+const _ETx = "ExceptionType";
+const _En = "Entries";
+const _Ex = "Expression";
+const _F = "Failures";
+const _FA = "FirehoseArn";
+const _FC = "FailureCode";
+const _FD = "FailureDescription";
+const _FR = "FailureResource";
+const _GAMR = "GetAlarmMuteRule";
+const _GAMRI = "GetAlarmMuteRuleInput";
+const _GAMRO = "GetAlarmMuteRuleOutput";
+const _GD = "GetDashboard";
+const _GDI = "GetDashboardInput";
+const _GDIe = "GetDatasetInput";
+const _GDO = "GetDashboardOutput";
+const _GDOe = "GetDatasetOutput";
+const _GDe = "GetDataset";
+const _GIRR = "GetInsightRuleReport";
+const _GIRRI = "GetInsightRuleReportInput";
+const _GIRRO = "GetInsightRuleReportOutput";
+const _GMD = "GetMetricData";
+const _GMDI = "GetMetricDataInput";
+const _GMDO = "GetMetricDataOutput";
+const _GMS = "GetMetricStatistics";
+const _GMSI = "GetMetricStatisticsInput";
+const _GMSIe = "GetMetricStreamInput";
+const _GMSO = "GetMetricStatisticsOutput";
+const _GMSOe = "GetMetricStreamOutput";
+const _GMSe = "GetMetricStream";
+const _GMWI = "GetMetricWidgetImage";
+const _GMWII = "GetMetricWidgetImageInput";
+const _GMWIO = "GetMetricWidgetImageOutput";
+const _GOTE = "GetOTelEnrichment";
+const _GOTEI = "GetOTelEnrichmentInput";
+const _GOTEO = "GetOTelEnrichmentOutput";
+const _HD = "HistoryData";
+const _HIT = "HistoryItemType";
+const _HS = "HistorySummary";
+const _I = "Id";
+const _IDA = "InsufficientDataActions";
+const _IF = "IncludeFilters";
+const _IFF = "InvalidFormatFault";
+const _ILA = "IncludeLinkedAccounts";
+const _ILAM = "IncludeLinkedAccountsMetrics";
+const _IM = "IncludeMetrics";
+const _INT = "InvalidNextToken";
+const _IPCE = "InvalidParameterCombinationException";
+const _IPVE = "InvalidParameterValueException";
+const _IR = "InsightRules";
+const _IRC = "InsightRuleContributor";
+const _IRCD = "InsightRuleContributorDatapoint";
+const _IRCDn = "InsightRuleContributorDatapoints";
+const _IRCn = "InsightRuleContributors";
+const _IRMD = "InsightRuleMetricDatapoint";
+const _IRMDn = "InsightRuleMetricDatapoints";
+const _IRn = "InsightRule";
+const _ISF = "InternalServiceFault";
+const _K = "Keys";
+const _KA = "KeyAttributes";
+const _KADE = "KmsAccessDeniedException";
+const _KKA = "KmsKeyArn";
+const _KKDE = "KmsKeyDisabledException";
+const _KKNFE = "KmsKeyNotFoundException";
+const _KL = "KeyLabels";
+const _Ke = "Key";
+const _L = "Label";
+const _LA = "LogAlarms";
+const _LAMR = "ListAlarmMuteRules";
+const _LAMRI = "ListAlarmMuteRulesInput";
+const _LAMRO = "ListAlarmMuteRulesOutput";
+const _LAo = "LogAlarm";
+const _LD = "ListDashboards";
+const _LDI = "ListDashboardsInput";
+const _LDO = "ListDashboardsOutput";
+const _LEE = "LimitExceededException";
+const _LEF = "LimitExceededFault";
+const _LGI = "LogGroupIdentifiers";
+const _LM = "LastModified";
+const _LMI = "ListMetricsInput";
+const _LMIR = "ListManagedInsightRules";
+const _LMIRI = "ListManagedInsightRulesInput";
+const _LMIRO = "ListManagedInsightRulesOutput";
+const _LMO = "ListMetricsOutput";
+const _LMS = "ListMetricStreams";
+const _LMSI = "ListMetricStreamsInput";
+const _LMSO = "ListMetricStreamsOutput";
+const _LMi = "ListMetrics";
+const _LO = "LabelOptions";
+const _LTFR = "ListTagsForResource";
+const _LTFRI = "ListTagsForResourceInput";
+const _LTFRO = "ListTagsForResourceOutput";
+const _LUD = "LastUpdateDate";
+const _LUT = "LastUpdatedTimestamp";
+const _M = "Message";
+const _MA = "MetricAlarms";
+const _MAe = "MetricAlarm";
+const _MC = "MetricCharacteristics";
+const _MCC = "MaxContributorCount";
+const _MCV = "MaxContributorValue";
+const _MD = "MetricData";
+const _MDQ = "MetricDataQueries";
+const _MDQe = "MetricDataQuery";
+const _MDR = "MetricDataResults";
+const _MDRM = "MetricDataResultMessages";
+const _MDRe = "MetricDataResult";
+const _MDa = "MaxDatapoints";
+const _MDe = "MetricDatapoints";
+const _MDes = "MessageData";
+const _MDet = "MetricDatum";
+const _MMAD = "MetricMathAnomalyDetector";
+const _MN = "MetricName";
+const _MNe = "MetricNames";
+const _MR = "MaxRecords";
+const _MRD = "ManagedRuleDescription";
+const _MRDa = "ManagedRuleDescriptions";
+const _MRPE = "MissingRequiredParameterException";
+const _MRS = "ManagedRuleState";
+const _MRa = "MaxResults";
+const _MRan = "ManagedRule";
+const _MRana = "ManagedRules";
+const _MS = "MetricStat";
+const _MSE = "MetricStreamEntry";
+const _MSEe = "MetricStreamEntries";
+const _MSF = "MetricStreamFilter";
+const _MSFe = "MetricStreamFilters";
+const _MSSC = "MetricStreamStatisticsConfiguration";
+const _MSSCe = "MetricStreamStatisticsConfigurations";
+const _MSSIM = "MetricStreamStatisticsIncludeMetrics";
+const _MSSM = "MetricStreamStatisticsMetric";
+const _MT = "MuteType";
+const _MTe = "MetricTimezone";
+const _MTu = "MuteTargets";
+const _MW = "MetricWidget";
+const _MWI = "MetricWidgetImage";
+const _Ma = "Maximum";
+const _Me = "Metrics";
+const _Mes = "Messages";
+const _Met = "Metric";
+const _Mi = "Minimum";
+const _N = "Namespace";
+const _NT = "NextToken";
+const _Na = "Name";
+const _Nam = "Names";
+const _OA = "OwningAccount";
+const _OAw = "OwningAccounts";
+const _OB = "OrderBy";
+const _OF = "OutputFormat";
+const _OKA = "OKActions";
+const _P = "Period";
+const _PAD = "PutAnomalyDetector";
+const _PADI = "PutAnomalyDetectorInput";
+const _PADO = "PutAnomalyDetectorOutput";
+const _PAMR = "PutAlarmMuteRule";
+const _PAMRI = "PutAlarmMuteRuleInput";
+const _PCA = "PutCompositeAlarm";
+const _PCAI = "PutCompositeAlarmInput";
+const _PD = "PutDashboard";
+const _PDI = "PutDashboardInput";
+const _PDO = "PutDashboardOutput";
+const _PF = "PartialFailure";
+const _PIR = "PutInsightRule";
+const _PIRI = "PutInsightRuleInput";
+const _PIRO = "PutInsightRuleOutput";
+const _PLA = "PutLogAlarm";
+const _PLAI = "PutLogAlarmInput";
+const _PMA = "PutMetricAlarm";
+const _PMAI = "PutMetricAlarmInput";
+const _PMD = "PutMetricData";
+const _PMDI = "PutMetricDataInput";
+const _PMIR = "PutManagedInsightRules";
+const _PMIRI = "PutManagedInsightRulesInput";
+const _PMIRO = "PutManagedInsightRulesOutput";
+const _PMS = "PutMetricStream";
+const _PMSI = "PutMetricStreamInput";
+const _PMSO = "PutMetricStreamOutput";
+const _POAN = "ParentsOfAlarmName";
+const _PP = "PendingPeriod";
+const _PQLC = "PromQLCriteria";
+const _PS = "PeriodicSpikes";
+const _Q = "Query";
+const _QARN = "QueryARN";
+const _QRTA = "QueryResultsToAlarm";
+const _QRTE = "QueryResultsToEvaluate";
+const _QS = "QueryString";
+const _R = "Rule";
+const _RA = "RoleArn";
+const _RARN = "ResourceARN";
+const _RAe = "RecentlyActive";
+const _RC = "ResourceConflict";
+const _RD = "ReturnData";
+const _RDu = "RuleDefinition";
+const _RI = "ResourceId";
+const _RN = "RuleNames";
+const _RNF = "ResourceNotFound";
+const _RNFE = "ResourceNotFoundException";
+const _RNu = "RuleName";
+const _RP = "RecoveryPeriod";
+const _RS = "RuleState";
+const _RT = "ResourceType";
+const _Ra = "Range";
+const _S = "Status";
+const _SAS = "SetAlarmState";
+const _SASI = "SetAlarmStateInput";
+const _SB = "ScanBy";
+const _SC = "SampleCount";
+const _SCc = "ScheduleConfiguration";
+const _SCt = "StatisticsConfigurations";
+const _SCta = "StatusCode";
+const _SD = "StartDate";
+const _SE = "ScheduleExpression";
+const _SEV = "StrictEntityValidation";
+const _SMAD = "SingleMetricAnomalyDetector";
+const _SMS = "StartMetricStreams";
+const _SMSI = "StartMetricStreamsInput";
+const _SMSIt = "StopMetricStreamsInput";
+const _SMSO = "StartMetricStreamsOutput";
+const _SMSOt = "StopMetricStreamsOutput";
+const _SMSt = "StopMetricStreams";
+const _SOTE = "StartOTelEnrichment";
+const _SOTEI = "StartOTelEnrichmentInput";
+const _SOTEIt = "StopOTelEnrichmentInput";
+const _SOTEO = "StartOTelEnrichmentOutput";
+const _SOTEOt = "StopOTelEnrichmentOutput";
+const _SOTEt = "StopOTelEnrichment";
+const _SQC = "ScheduledQueryConfiguration";
+const _SQRARN = "ScheduledQueryRoleARN";
+const _SR = "StateReason";
+const _SRD = "StateReasonData";
+const _SRt = "StorageResolution";
+const _SS = "StatisticSet";
+const _ST = "StartTime";
+const _STO = "StartTimeOffset";
+const _STT = "StateTransitionedTimestamp";
+const _SUT = "StateUpdatedTimestamp";
+const _SV = "StateValue";
+const _SVt = "StatisticValues";
+const _Sc = "Schema";
+const _Sch = "Schedule";
+const _Si = "Size";
+const _St = "Stat";
+const _Sta = "Statistic";
+const _Stat = "Statistics";
+const _State = "State";
+const _Statu = "Statuses";
+const _Su = "Sum";
+const _T = "Timestamp";
+const _TK = "TagKeys";
+const _TL = "TagList";
+const _TMD = "TreatMissingData";
+const _TMI = "ThresholdMetricId";
+const _TN = "TemplateName";
+const _TR = "TagResource";
+const _TRI = "TagResourceInput";
+const _TRO = "TagResourceOutput";
+const _Ta = "Tags";
+const _Tag = "Tag";
+const _Th = "Threshold";
+const _Ti = "Timezone";
+const _Tim = "Timestamps";
+const _U = "Unit";
+const _UC = "UniqueContributors";
+const _UR = "UntagResource";
+const _URI = "UntagResourceInput";
+const _URO = "UntagResourceOutput";
+const _V = "Value";
+const _Va = "Values";
+const _aQE = "awsQueryError";
+const _c = "client";
+const _dVM = "dashboardValidationMessages";
+const _e = "error";
+const _hE = "httpError";
+const _m = "message";
+const _s = "smithy.ts.sdk.synthetic.com.amazonaws.cloudwatch";
+const _se = "server";
+const n0 = "com.amazonaws.cloudwatch";
+const _s_registry = TypeRegistry.for(_s);
+var CloudWatchServiceException$ = [-3, _s, "CloudWatchServiceException", 0, [], []];
+_s_registry.registerError(CloudWatchServiceException$, CloudWatchServiceException);
+const n0_registry = TypeRegistry.for(n0);
+var ConcurrentModificationException$ = [-3, n0, _CME,
+    { [_aQE]: [`ConcurrentModificationException`, 429], [_e]: _c, [_hE]: 429 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(ConcurrentModificationException$, ConcurrentModificationException);
+var ConflictException$ = [-3, n0, _CE,
+    { [_e]: _c, [_hE]: 409 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(ConflictException$, ConflictException);
+var DashboardInvalidInputError$ = [-3, n0, _DIIE,
+    { [_aQE]: [`InvalidParameterInput`, 400], [_e]: _c, [_hE]: 400 },
+    [_m, _dVM],
+    [0, () => DashboardValidationMessages]
+];
+n0_registry.registerError(DashboardInvalidInputError$, DashboardInvalidInputError);
+var DashboardNotFoundError$ = [-3, n0, _DNFE,
+    { [_aQE]: [`ResourceNotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(DashboardNotFoundError$, DashboardNotFoundError);
+var InternalServiceFault$ = [-3, n0, _ISF,
+    { [_aQE]: [`InternalServiceError`, 500], [_e]: _se, [_hE]: 500 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(InternalServiceFault$, InternalServiceFault);
+var InvalidFormatFault$ = [-3, n0, _IFF,
+    { [_aQE]: [`InvalidFormat`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidFormatFault$, InvalidFormatFault);
+var InvalidNextToken$ = [-3, n0, _INT,
+    { [_aQE]: [`InvalidNextToken`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidNextToken$, InvalidNextToken);
+var InvalidParameterCombinationException$ = [-3, n0, _IPCE,
+    { [_aQE]: [`InvalidParameterCombination`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidParameterCombinationException$, InvalidParameterCombinationException);
+var InvalidParameterValueException$ = [-3, n0, _IPVE,
+    { [_aQE]: [`InvalidParameterValue`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(InvalidParameterValueException$, InvalidParameterValueException);
+var KmsAccessDeniedException$ = [-3, n0, _KADE,
+    { [_e]: _c },
+    [_M],
+    [0], 1
+];
+n0_registry.registerError(KmsAccessDeniedException$, KmsAccessDeniedException);
+var KmsKeyDisabledException$ = [-3, n0, _KKDE,
+    { [_e]: _c },
+    [_M],
+    [0], 1
+];
+n0_registry.registerError(KmsKeyDisabledException$, KmsKeyDisabledException);
+var KmsKeyNotFoundException$ = [-3, n0, _KKNFE,
+    { [_e]: _c },
+    [_M],
+    [0], 1
+];
+n0_registry.registerError(KmsKeyNotFoundException$, KmsKeyNotFoundException);
+var LimitExceededException$ = [-3, n0, _LEE,
+    { [_aQE]: [`LimitExceededException`, 400], [_e]: _c, [_hE]: 400 },
+    [_M],
+    [0]
+];
+n0_registry.registerError(LimitExceededException$, LimitExceededException);
+var LimitExceededFault$ = [-3, n0, _LEF,
+    { [_aQE]: [`LimitExceeded`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(LimitExceededFault$, LimitExceededFault);
+var MissingRequiredParameterException$ = [-3, n0, _MRPE,
+    { [_aQE]: [`MissingParameter`, 400], [_e]: _c, [_hE]: 400 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(MissingRequiredParameterException$, MissingRequiredParameterException);
+var ResourceConflict$ = [-3, n0, _RC,
+    { [_aQE]: [`ResourceConflict`, 409], [_e]: _c, [_hE]: 409 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ResourceConflict$, ResourceConflict);
+var ResourceNotFound$ = [-3, n0, _RNF,
+    { [_aQE]: [`ResourceNotFound`, 404], [_e]: _c, [_hE]: 404 },
+    [_m],
+    [0]
+];
+n0_registry.registerError(ResourceNotFound$, ResourceNotFound);
+var ResourceNotFoundException$ = [-3, n0, _RNFE,
+    { [_aQE]: [`ResourceNotFoundException`, 404], [_e]: _c, [_hE]: 404 },
+    [_RT, _RI, _M],
+    [0, 0, 0]
+];
+n0_registry.registerError(ResourceNotFoundException$, ResourceNotFoundException);
+const errorTypeRegistries = [
+    _s_registry,
+    n0_registry,
+];
+var AlarmContributor$ = [3, n0, _AC,
+    0,
+    [_CI, _CA, _SR, _STT],
+    [0, 128 | 0, 0, 4], 3
+];
+var AlarmHistoryItem$ = [3, n0, _AHI,
+    0,
+    [_AN, _ACI, _AT, _T, _HIT, _HS, _HD, _ACA],
+    [0, 0, 0, 4, 0, 0, 0, 128 | 0]
+];
+var AlarmMuteRuleSummary$ = [3, n0, _AMRS,
+    0,
+    [_AMRA, _ED, _S, _MT, _LUT],
+    [0, 4, 0, 0, 4]
+];
+var AlarmPromQLCriteria$ = [3, n0, _APQLC,
+    0,
+    [_Q, _PP, _RP],
+    [0, 1, 1], 1
+];
+var AnomalyDetector$ = [3, n0, _AD,
+    0,
+    [_N, _MN, _D, _St, _C, _SV, _MC, _SMAD, _MMAD],
+    [0, 0, () => Dimensions, 0, () => AnomalyDetectorConfiguration$, 0, () => MetricCharacteristics$, () => SingleMetricAnomalyDetector$, () => MetricMathAnomalyDetector$]
+];
+var AnomalyDetectorConfiguration$ = [3, n0, _ADC,
+    0,
+    [_ETR, _MTe],
+    [() => AnomalyDetectorExcludedTimeRanges, 0]
+];
+var AssociateDatasetKmsKeyInput$ = [3, n0, _ADKKI,
+    0,
+    [_DI, _KKA],
+    [0, 0], 2
+];
+var AssociateDatasetKmsKeyOutput$ = [3, n0, _ADKKO,
+    0,
+    [],
+    []
+];
+var CompositeAlarm$ = [3, n0, _CAo,
+    0,
+    [_AE, _AA, _AAl, _ACUT, _ADl, _AN, _AR, _IDA, _OKA, _SR, _SRD, _SUT, _SV, _STT, _ASB, _ASR, _AS, _ASWP, _ASEP],
+    [2, 64 | 0, 0, 4, 0, 0, 0, 64 | 0, 64 | 0, 0, 0, 4, 0, 4, 0, 0, 0, 1, 1]
+];
+var DashboardEntry$ = [3, n0, _DE,
+    0,
+    [_DN, _DA, _LM, _Si],
+    [0, 0, 4, 1]
+];
+var DashboardValidationMessage$ = [3, n0, _DVM,
+    0,
+    [_DP, _M],
+    [0, 0]
+];
+var Datapoint$ = [3, n0, _Da,
+    0,
+    [_T, _SC, _A, _Su, _Mi, _Ma, _U, _ES],
+    [4, 1, 1, 1, 1, 1, 0, 128 | 1]
+];
+var DeleteAlarmMuteRuleInput$ = [3, n0, _DAMRI,
+    0,
+    [_AMRN],
+    [0], 1
+];
+var DeleteAlarmsInput$ = [3, n0, _DAI,
+    0,
+    [_ANl],
+    [64 | 0], 1
+];
+var DeleteAnomalyDetectorInput$ = [3, n0, _DADI,
+    0,
+    [_N, _MN, _D, _St, _SMAD, _MMAD],
+    [0, 0, () => Dimensions, 0, () => SingleMetricAnomalyDetector$, () => MetricMathAnomalyDetector$]
+];
+var DeleteAnomalyDetectorOutput$ = [3, n0, _DADO,
+    0,
+    [],
+    []
+];
+var DeleteDashboardsInput$ = [3, n0, _DDI,
+    0,
+    [_DNa],
+    [64 | 0], 1
+];
+var DeleteDashboardsOutput$ = [3, n0, _DDO,
+    0,
+    [],
+    []
+];
+var DeleteInsightRulesInput$ = [3, n0, _DIRI,
+    0,
+    [_RN],
+    [64 | 0], 1
+];
+var DeleteInsightRulesOutput$ = [3, n0, _DIRO,
+    0,
+    [_F],
+    [() => BatchFailures]
+];
+var DeleteMetricStreamInput$ = [3, n0, _DMSI,
+    0,
+    [_Na],
+    [0], 1
+];
+var DeleteMetricStreamOutput$ = [3, n0, _DMSO,
+    0,
+    [],
+    []
+];
+var DescribeAlarmContributorsInput$ = [3, n0, _DACI,
+    0,
+    [_AN, _NT],
+    [0, 0], 1
+];
+var DescribeAlarmContributorsOutput$ = [3, n0, _DACO,
+    0,
+    [_ACl, _NT],
+    [() => AlarmContributors, 0], 1
+];
+var DescribeAlarmHistoryInput$ = [3, n0, _DAHI,
+    0,
+    [_AN, _ACI, _ATl, _HIT, _SD, _EDn, _MR, _NT, _SB],
+    [0, 0, 64 | 0, 0, 4, 4, 1, 0, 0]
+];
+var DescribeAlarmHistoryOutput$ = [3, n0, _DAHO,
+    0,
+    [_AHIl, _NT],
+    [() => AlarmHistoryItems, 0]
+];
+var DescribeAlarmsForMetricInput$ = [3, n0, _DAFMI,
+    0,
+    [_MN, _N, _Sta, _ESx, _D, _P, _U],
+    [0, 0, 0, 0, () => Dimensions, 1, 0], 2
+];
+var DescribeAlarmsForMetricOutput$ = [3, n0, _DAFMO,
+    0,
+    [_MA],
+    [() => MetricAlarms]
+];
+var DescribeAlarmsInput$ = [3, n0, _DAIe,
+    0,
+    [_ANl, _ANP, _ATl, _COAN, _POAN, _SV, _AP, _MR, _NT],
+    [64 | 0, 0, 64 | 0, 0, 0, 0, 0, 1, 0]
+];
+var DescribeAlarmsOutput$ = [3, n0, _DAO,
+    0,
+    [_CAom, _MA, _LA, _NT],
+    [() => CompositeAlarms, () => MetricAlarms, () => LogAlarms, 0]
+];
+var DescribeAnomalyDetectorsInput$ = [3, n0, _DADIe,
+    0,
+    [_NT, _MRa, _N, _MN, _D, _ADT],
+    [0, 1, 0, 0, () => Dimensions, 64 | 0]
+];
+var DescribeAnomalyDetectorsOutput$ = [3, n0, _DADOe,
+    0,
+    [_ADn, _NT],
+    [() => AnomalyDetectors, 0]
+];
+var DescribeInsightRulesInput$ = [3, n0, _DIRIe,
+    0,
+    [_NT, _MRa],
+    [0, 1]
+];
+var DescribeInsightRulesOutput$ = [3, n0, _DIROe,
+    0,
+    [_NT, _IR],
+    [0, () => InsightRules]
+];
+var Dimension$ = [3, n0, _Di,
+    0,
+    [_Na, _V],
+    [0, 0], 2
+];
+var DimensionFilter$ = [3, n0, _DF,
+    0,
+    [_Na, _V],
+    [0, 0], 1
+];
+var DisableAlarmActionsInput$ = [3, n0, _DAAI,
+    0,
+    [_ANl],
+    [64 | 0], 1
+];
+var DisableInsightRulesInput$ = [3, n0, _DIRIi,
+    0,
+    [_RN],
+    [64 | 0], 1
+];
+var DisableInsightRulesOutput$ = [3, n0, _DIROi,
+    0,
+    [_F],
+    [() => BatchFailures]
+];
+var DisassociateDatasetKmsKeyInput$ = [3, n0, _DDKKI,
+    0,
+    [_DI],
+    [0], 1
+];
+var DisassociateDatasetKmsKeyOutput$ = [3, n0, _DDKKO,
+    0,
+    [],
+    []
+];
+var EnableAlarmActionsInput$ = [3, n0, _EAAI,
+    0,
+    [_ANl],
+    [64 | 0], 1
+];
+var EnableInsightRulesInput$ = [3, n0, _EIRI,
+    0,
+    [_RN],
+    [64 | 0], 1
+];
+var EnableInsightRulesOutput$ = [3, n0, _EIRO,
+    0,
+    [_F],
+    [() => BatchFailures]
+];
+var Entity$ = [3, n0, _E,
+    0,
+    [_KA, _At],
+    [128 | 0, 128 | 0]
+];
+var EntityMetricData$ = [3, n0, _EMD,
+    0,
+    [_E, _MD],
+    [() => Entity$, () => MetricData]
+];
+var GetAlarmMuteRuleInput$ = [3, n0, _GAMRI,
+    0,
+    [_AMRN],
+    [0], 1
+];
+var GetAlarmMuteRuleOutput$ = [3, n0, _GAMRO,
+    0,
+    [_Na, _AMRA, _De, _R, _MTu, _SD, _ED, _S, _LUT, _MT],
+    [0, 0, 0, () => Rule$, () => MuteTargets$, 4, 4, 0, 4, 0]
+];
+var GetDashboardInput$ = [3, n0, _GDI,
+    0,
+    [_DN],
+    [0], 1
+];
+var GetDashboardOutput$ = [3, n0, _GDO,
+    0,
+    [_DA, _DB, _DN],
+    [0, 0, 0]
+];
+var GetDatasetInput$ = [3, n0, _GDIe,
+    0,
+    [_DI],
+    [0], 1
+];
+var GetDatasetOutput$ = [3, n0, _GDOe,
+    0,
+    [_DIa, _Ar, _KKA],
+    [0, 0, 0], 2
+];
+var GetInsightRuleReportInput$ = [3, n0, _GIRRI,
+    0,
+    [_RNu, _ST, _ET, _P, _MCC, _Me, _OB],
+    [0, 4, 4, 1, 1, 64 | 0, 0], 4
+];
+var GetInsightRuleReportOutput$ = [3, n0, _GIRRO,
+    0,
+    [_KL, _ASg, _AV, _AUC, _Co, _MDe],
+    [64 | 0, 0, 1, 1, () => InsightRuleContributors, () => InsightRuleMetricDatapoints]
+];
+var GetMetricDataInput$ = [3, n0, _GMDI,
+    0,
+    [_MDQ, _ST, _ET, _NT, _SB, _MDa, _LO],
+    [() => MetricDataQueries, 4, 4, 0, 0, 1, () => LabelOptions$], 3
+];
+var GetMetricDataOutput$ = [3, n0, _GMDO,
+    0,
+    [_MDR, _NT, _Mes],
+    [() => MetricDataResults, 0, () => MetricDataResultMessages]
+];
+var GetMetricStatisticsInput$ = [3, n0, _GMSI,
+    0,
+    [_N, _MN, _ST, _ET, _P, _D, _Stat, _ES, _U],
+    [0, 0, 4, 4, 1, () => Dimensions, 64 | 0, 64 | 0, 0], 5
+];
+var GetMetricStatisticsOutput$ = [3, n0, _GMSO,
+    0,
+    [_L, _Dat],
+    [0, () => Datapoints]
+];
+var GetMetricStreamInput$ = [3, n0, _GMSIe,
+    0,
+    [_Na],
+    [0], 1
+];
+var GetMetricStreamOutput$ = [3, n0, _GMSOe,
+    0,
+    [_Ar, _Na, _IF, _EF, _FA, _RA, _State, _CD, _LUD, _OF, _SCt, _ILAM],
+    [0, 0, () => MetricStreamFilters, () => MetricStreamFilters, 0, 0, 0, 4, 4, 0, () => MetricStreamStatisticsConfigurations, 2]
+];
+var GetMetricWidgetImageInput$ = [3, n0, _GMWII,
+    0,
+    [_MW, _OF],
+    [0, 0], 1
+];
+var GetMetricWidgetImageOutput$ = [3, n0, _GMWIO,
+    0,
+    [_MWI],
+    [21]
+];
+var GetOTelEnrichmentInput$ = [3, n0, _GOTEI,
+    0,
+    [],
+    []
+];
+var GetOTelEnrichmentOutput$ = [3, n0, _GOTEO,
+    0,
+    [_S],
+    [0], 1
+];
+var InsightRule$ = [3, n0, _IRn,
+    0,
+    [_Na, _State, _Sc, _Def, _MRan, _AOTL],
+    [0, 0, 0, 0, 2, 2], 4
+];
+var InsightRuleContributor$ = [3, n0, _IRC,
+    0,
+    [_K, _AAV, _Dat],
+    [64 | 0, 1, () => InsightRuleContributorDatapoints], 3
+];
+var InsightRuleContributorDatapoint$ = [3, n0, _IRCD,
+    0,
+    [_T, _AVp],
+    [4, 1], 2
+];
+var InsightRuleMetricDatapoint$ = [3, n0, _IRMD,
+    0,
+    [_T, _UC, _MCV, _SC, _A, _Su, _Mi, _Ma],
+    [4, 1, 1, 1, 1, 1, 1, 1], 1
+];
+var LabelOptions$ = [3, n0, _LO,
+    0,
+    [_Ti],
+    [0]
+];
+var ListAlarmMuteRulesInput$ = [3, n0, _LAMRI,
+    0,
+    [_AN, _Statu, _MR, _NT],
+    [0, 64 | 0, 1, 0]
+];
+var ListAlarmMuteRulesOutput$ = [3, n0, _LAMRO,
+    0,
+    [_AMRSl, _NT],
+    [() => AlarmMuteRuleSummaries, 0]
+];
+var ListDashboardsInput$ = [3, n0, _LDI,
+    0,
+    [_DNP, _NT],
+    [0, 0]
+];
+var ListDashboardsOutput$ = [3, n0, _LDO,
+    0,
+    [_DEa, _NT],
+    [() => DashboardEntries, 0]
+];
+var ListManagedInsightRulesInput$ = [3, n0, _LMIRI,
+    0,
+    [_RARN, _NT, _MRa],
+    [0, 0, 1], 1
+];
+var ListManagedInsightRulesOutput$ = [3, n0, _LMIRO,
+    0,
+    [_MRana, _NT],
+    [() => ManagedRuleDescriptions, 0]
+];
+var ListMetricsInput$ = [3, n0, _LMI,
+    0,
+    [_N, _MN, _D, _NT, _RAe, _ILA, _OA],
+    [0, 0, () => DimensionFilters, 0, 0, 2, 0]
+];
+var ListMetricsOutput$ = [3, n0, _LMO,
+    0,
+    [_Me, _NT, _OAw],
+    [() => Metrics, 0, 64 | 0]
+];
+var ListMetricStreamsInput$ = [3, n0, _LMSI,
+    0,
+    [_NT, _MRa],
+    [0, 1]
+];
+var ListMetricStreamsOutput$ = [3, n0, _LMSO,
+    0,
+    [_NT, _En],
+    [0, () => MetricStreamEntries]
+];
+var ListTagsForResourceInput$ = [3, n0, _LTFRI,
+    0,
+    [_RARN],
+    [0], 1
+];
+var ListTagsForResourceOutput$ = [3, n0, _LTFRO,
+    0,
+    [_Ta],
+    [() => TagList]
+];
+var LogAlarm$ = [3, n0, _LAo,
+    0,
+    [_AN, _AAl, _ADl, _ACUT, _AE, _OKA, _AA, _IDA, _SV, _SR, _SRD, _SUT, _SQC, _QRTE, _QRTA, _Th, _CO, _TMD, _STT, _ESv, _ALLC, _ALLRA],
+    [0, 0, 0, 4, 2, 64 | 0, 64 | 0, 64 | 0, 0, 0, 0, 4, () => ScheduledQueryConfiguration$, 1, 1, 1, 0, 0, 4, 0, 1, 0]
+];
+var ManagedRule$ = [3, n0, _MRan,
+    0,
+    [_TN, _RARN, _Ta],
+    [0, 0, () => TagList], 2
+];
+var ManagedRuleDescription$ = [3, n0, _MRD,
+    0,
+    [_TN, _RARN, _RS],
+    [0, 0, () => ManagedRuleState$]
+];
+var ManagedRuleState$ = [3, n0, _MRS,
+    0,
+    [_RNu, _State],
+    [0, 0], 2
+];
+var MessageData$ = [3, n0, _MDes,
+    0,
+    [_Cod, _V],
+    [0, 0]
+];
+var Metric$ = [3, n0, _Met,
+    0,
+    [_N, _MN, _D],
+    [0, 0, () => Dimensions]
+];
+var MetricAlarm$ = [3, n0, _MAe,
+    0,
+    [_AN, _AAl, _ADl, _ACUT, _AE, _OKA, _AA, _IDA, _SV, _SR, _SRD, _SUT, _MN, _N, _Sta, _ESx, _D, _P, _U, _EP, _DTA, _Th, _CO, _TMD, _ELSCP, _Me, _TMI, _ESv, _STT, _EC, _EI],
+    [0, 0, 0, 4, 2, 64 | 0, 64 | 0, 64 | 0, 0, 0, 0, 4, 0, 0, 0, 0, () => Dimensions, 1, 0, 1, 1, 1, 0, 0, 0, () => MetricDataQueries, 0, 0, 4, () => EvaluationCriteria$, 1]
+];
+var MetricCharacteristics$ = [3, n0, _MC,
+    0,
+    [_PS],
+    [2]
+];
+var MetricDataQuery$ = [3, n0, _MDQe,
+    0,
+    [_I, _MS, _Ex, _L, _RD, _P, _AI],
+    [0, () => MetricStat$, 0, 0, 2, 1, 0], 1
+];
+var MetricDataResult$ = [3, n0, _MDRe,
+    0,
+    [_I, _L, _Tim, _Va, _SCta, _Mes],
+    [0, 0, 64 | 4, 64 | 1, 0, () => MetricDataResultMessages]
+];
+var MetricDatum$ = [3, n0, _MDet,
+    0,
+    [_MN, _D, _T, _V, _SVt, _Va, _Cou, _U, _SRt],
+    [0, () => Dimensions, 4, 1, () => StatisticSet$, 64 | 1, 64 | 1, 0, 1], 1
+];
+var MetricMathAnomalyDetector$ = [3, n0, _MMAD,
+    0,
+    [_MDQ],
+    [() => MetricDataQueries]
+];
+var MetricStat$ = [3, n0, _MS,
+    0,
+    [_Met, _P, _St, _U],
+    [() => Metric$, 1, 0, 0], 3
+];
+var MetricStreamEntry$ = [3, n0, _MSE,
+    0,
+    [_Ar, _CD, _LUD, _Na, _FA, _State, _OF],
+    [0, 4, 4, 0, 0, 0, 0]
+];
+var MetricStreamFilter$ = [3, n0, _MSF,
+    0,
+    [_N, _MNe],
+    [0, 64 | 0]
+];
+var MetricStreamStatisticsConfiguration$ = [3, n0, _MSSC,
+    0,
+    [_IM, _ASd],
+    [() => MetricStreamStatisticsIncludeMetrics, 64 | 0], 2
+];
+var MetricStreamStatisticsMetric$ = [3, n0, _MSSM,
+    0,
+    [_N, _MN],
+    [0, 0], 2
+];
+var MuteTargets$ = [3, n0, _MTu,
+    0,
+    [_ANl],
+    [64 | 0], 1
+];
+var PartialFailure$ = [3, n0, _PF,
+    0,
+    [_FR, _ETx, _FC, _FD],
+    [0, 0, 0, 0]
+];
+var PutAlarmMuteRuleInput$ = [3, n0, _PAMRI,
+    0,
+    [_Na, _R, _De, _MTu, _Ta, _SD, _ED],
+    [0, () => Rule$, 0, () => MuteTargets$, () => TagList, 4, 4], 2
+];
+var PutAnomalyDetectorInput$ = [3, n0, _PADI,
+    0,
+    [_N, _MN, _D, _St, _C, _MC, _SMAD, _MMAD],
+    [0, 0, () => Dimensions, 0, () => AnomalyDetectorConfiguration$, () => MetricCharacteristics$, () => SingleMetricAnomalyDetector$, () => MetricMathAnomalyDetector$]
+];
+var PutAnomalyDetectorOutput$ = [3, n0, _PADO,
+    0,
+    [],
+    []
+];
+var PutCompositeAlarmInput$ = [3, n0, _PCAI,
+    0,
+    [_AN, _AR, _AE, _AA, _ADl, _IDA, _OKA, _Ta, _AS, _ASWP, _ASEP],
+    [0, 0, 2, 64 | 0, 0, 64 | 0, 64 | 0, () => TagList, 0, 1, 1], 2
+];
+var PutDashboardInput$ = [3, n0, _PDI,
+    0,
+    [_DN, _DB, _Ta],
+    [0, 0, () => TagList], 2
+];
+var PutDashboardOutput$ = [3, n0, _PDO,
+    0,
+    [_DVMa],
+    [() => DashboardValidationMessages]
+];
+var PutInsightRuleInput$ = [3, n0, _PIRI,
+    0,
+    [_RNu, _RDu, _RS, _Ta, _AOTL],
+    [0, 0, 0, () => TagList, 2], 2
+];
+var PutInsightRuleOutput$ = [3, n0, _PIRO,
+    0,
+    [],
+    []
+];
+var PutLogAlarmInput$ = [3, n0, _PLAI,
+    0,
+    [_AN, _SQC, _QRTE, _QRTA, _Th, _CO, _ADl, _ALLC, _ALLRA, _AE, _OKA, _AA, _IDA, _TMD, _Ta],
+    [0, () => ScheduledQueryConfiguration$, 1, 1, 1, 0, 0, 1, 0, 2, 64 | 0, 64 | 0, 64 | 0, 0, () => TagList], 6
+];
+var PutManagedInsightRulesInput$ = [3, n0, _PMIRI,
+    0,
+    [_MRana],
+    [() => ManagedRules], 1
+];
+var PutManagedInsightRulesOutput$ = [3, n0, _PMIRO,
+    0,
+    [_F],
+    [() => BatchFailures]
+];
+var PutMetricAlarmInput$ = [3, n0, _PMAI,
+    0,
+    [_AN, _ADl, _AE, _OKA, _AA, _IDA, _MN, _N, _Sta, _ESx, _D, _P, _U, _EP, _DTA, _Th, _CO, _TMD, _ELSCP, _Me, _Ta, _TMI, _EC, _EI],
+    [0, 0, 2, 64 | 0, 64 | 0, 64 | 0, 0, 0, 0, 0, () => Dimensions, 1, 0, 1, 1, 1, 0, 0, 0, () => MetricDataQueries, () => TagList, 0, () => EvaluationCriteria$, 1], 1
+];
+var PutMetricDataInput$ = [3, n0, _PMDI,
+    0,
+    [_N, _MD, _EMD, _SEV],
+    [0, () => MetricData, () => EntityMetricDataList, 2], 1
+];
+var PutMetricStreamInput$ = [3, n0, _PMSI,
+    0,
+    [_Na, _FA, _RA, _OF, _IF, _EF, _Ta, _SCt, _ILAM],
+    [0, 0, 0, 0, () => MetricStreamFilters, () => MetricStreamFilters, () => TagList, () => MetricStreamStatisticsConfigurations, 2], 4
+];
+var PutMetricStreamOutput$ = [3, n0, _PMSO,
+    0,
+    [_Ar],
+    [0]
+];
+var Range$ = [3, n0, _Ra,
+    0,
+    [_ST, _ET],
+    [4, 4], 2
+];
+var Rule$ = [3, n0, _R,
+    0,
+    [_Sch],
+    [() => Schedule$], 1
+];
+var Schedule$ = [3, n0, _Sch,
+    0,
+    [_Ex, _Du, _Ti],
+    [0, 0, 0], 2
+];
+var ScheduleConfiguration$ = [3, n0, _SCc,
+    0,
+    [_SE, _STO, _ETO],
+    [0, 1, 1], 1
+];
+var ScheduledQueryConfiguration$ = [3, n0, _SQC,
+    0,
+    [_QS, _SQRARN, _SCc, _AEg, _LGI, _QARN, _Ta],
+    [0, 0, () => ScheduleConfiguration$, 0, 64 | 0, 0, () => TagList], 4
+];
+var SetAlarmStateInput$ = [3, n0, _SASI,
+    0,
+    [_AN, _SV, _SR, _SRD],
+    [0, 0, 0, 0], 3
+];
+var SingleMetricAnomalyDetector$ = [3, n0, _SMAD,
+    0,
+    [_AI, _N, _MN, _D, _St],
+    [0, 0, 0, () => Dimensions, 0]
+];
+var StartMetricStreamsInput$ = [3, n0, _SMSI,
+    0,
+    [_Nam],
+    [64 | 0], 1
+];
+var StartMetricStreamsOutput$ = [3, n0, _SMSO,
+    0,
+    [],
+    []
+];
+var StartOTelEnrichmentInput$ = [3, n0, _SOTEI,
+    0,
+    [],
+    []
+];
+var StartOTelEnrichmentOutput$ = [3, n0, _SOTEO,
+    0,
+    [],
+    []
+];
+var StatisticSet$ = [3, n0, _SS,
+    0,
+    [_SC, _Su, _Mi, _Ma],
+    [1, 1, 1, 1], 4
+];
+var StopMetricStreamsInput$ = [3, n0, _SMSIt,
+    0,
+    [_Nam],
+    [64 | 0], 1
+];
+var StopMetricStreamsOutput$ = [3, n0, _SMSOt,
+    0,
+    [],
+    []
+];
+var StopOTelEnrichmentInput$ = [3, n0, _SOTEIt,
+    0,
+    [],
+    []
+];
+var StopOTelEnrichmentOutput$ = [3, n0, _SOTEOt,
+    0,
+    [],
+    []
+];
+var Tag$ = [3, n0, _Tag,
+    0,
+    [_Ke, _V],
+    [0, 0], 2
+];
+var TagResourceInput$ = [3, n0, _TRI,
+    0,
+    [_RARN, _Ta],
+    [0, () => TagList], 2
+];
+var TagResourceOutput$ = [3, n0, _TRO,
+    0,
+    [],
+    []
+];
+var UntagResourceInput$ = [3, n0, _URI,
+    0,
+    [_RARN, _TK],
+    [0, 64 | 0], 2
+];
+var UntagResourceOutput$ = [3, n0, _URO,
+    0,
+    [],
+    []
+];
+var __Unit = "unit";
+var AlarmContributors = [1, n0, _ACl,
+    0, () => AlarmContributor$
+];
+var AlarmHistoryItems = [1, n0, _AHIl,
+    0, () => AlarmHistoryItem$
+];
+var AlarmMuteRuleSummaries = [1, n0, _AMRSl,
+    0, () => AlarmMuteRuleSummary$
+];
+var AnomalyDetectorExcludedTimeRanges = [1, n0, _ADETR,
+    0, () => Range$
+];
+var AnomalyDetectors = [1, n0, _ADn,
+    0, () => AnomalyDetector$
+];
+var BatchFailures = [1, n0, _BF,
+    0, () => PartialFailure$
+];
+var CompositeAlarms = [1, n0, _CAom,
+    0, () => CompositeAlarm$
+];
+var DashboardEntries = [1, n0, _DEa,
+    0, () => DashboardEntry$
+];
+var DashboardValidationMessages = [1, n0, _DVMa,
+    0, () => DashboardValidationMessage$
+];
+var Datapoints = [1, n0, _Dat,
+    0, () => Datapoint$
+];
+var DimensionFilters = [1, n0, _DFi,
+    0, () => DimensionFilter$
+];
+var Dimensions = [1, n0, _D,
+    0, () => Dimension$
+];
+var EntityMetricDataList = [1, n0, _EMDL,
+    0, () => EntityMetricData$
+];
+var InsightRuleContributorDatapoints = [1, n0, _IRCDn,
+    0, () => InsightRuleContributorDatapoint$
+];
+var InsightRuleContributors = [1, n0, _IRCn,
+    0, () => InsightRuleContributor$
+];
+var InsightRuleMetricDatapoints = [1, n0, _IRMDn,
+    0, () => InsightRuleMetricDatapoint$
+];
+var InsightRules = [1, n0, _IR,
+    0, () => InsightRule$
+];
+var LogAlarms = [1, n0, _LA,
+    0, () => LogAlarm$
+];
+var ManagedRuleDescriptions = [1, n0, _MRDa,
+    0, () => ManagedRuleDescription$
+];
+var ManagedRules = [1, n0, _MRana,
+    0, () => ManagedRule$
+];
+var MetricAlarms = [1, n0, _MA,
+    0, () => MetricAlarm$
+];
+var MetricData = [1, n0, _MD,
+    0, () => MetricDatum$
+];
+var MetricDataQueries = [1, n0, _MDQ,
+    0, () => MetricDataQuery$
+];
+var MetricDataResultMessages = [1, n0, _MDRM,
+    0, () => MessageData$
+];
+var MetricDataResults = [1, n0, _MDR,
+    0, () => MetricDataResult$
+];
+var Metrics = [1, n0, _Me,
+    0, () => Metric$
+];
+var MetricStreamEntries = [1, n0, _MSEe,
+    0, () => MetricStreamEntry$
+];
+var MetricStreamFilters = [1, n0, _MSFe,
+    0, () => MetricStreamFilter$
+];
+var MetricStreamStatisticsConfigurations = [1, n0, _MSSCe,
+    0, () => MetricStreamStatisticsConfiguration$
+];
+var MetricStreamStatisticsIncludeMetrics = [1, n0, _MSSIM,
+    0, () => MetricStreamStatisticsMetric$
+];
+var TagList = [1, n0, _TL,
+    0, () => Tag$
+];
+var EvaluationCriteria$ = [4, n0, _EC,
+    0,
+    [_PQLC],
+    [() => AlarmPromQLCriteria$]
+];
+var AssociateDatasetKmsKey$ = [9, n0, _ADKK,
+    0, () => AssociateDatasetKmsKeyInput$, () => AssociateDatasetKmsKeyOutput$
+];
+var DeleteAlarmMuteRule$ = [9, n0, _DAMR,
+    0, () => DeleteAlarmMuteRuleInput$, () => __Unit
+];
+var DeleteAlarms$ = [9, n0, _DAe,
+    0, () => DeleteAlarmsInput$, () => __Unit
+];
+var DeleteAnomalyDetector$ = [9, n0, _DAD,
+    0, () => DeleteAnomalyDetectorInput$, () => DeleteAnomalyDetectorOutput$
+];
+var DeleteDashboards$ = [9, n0, _DD,
+    0, () => DeleteDashboardsInput$, () => DeleteDashboardsOutput$
+];
+var DeleteInsightRules$ = [9, n0, _DIR,
+    0, () => DeleteInsightRulesInput$, () => DeleteInsightRulesOutput$
+];
+var DeleteMetricStream$ = [9, n0, _DMS,
+    0, () => DeleteMetricStreamInput$, () => DeleteMetricStreamOutput$
+];
+var DescribeAlarmContributors$ = [9, n0, _DAC,
+    0, () => DescribeAlarmContributorsInput$, () => DescribeAlarmContributorsOutput$
+];
+var DescribeAlarmHistory$ = [9, n0, _DAH,
+    0, () => DescribeAlarmHistoryInput$, () => DescribeAlarmHistoryOutput$
+];
+var DescribeAlarms$ = [9, n0, _DAes,
+    0, () => DescribeAlarmsInput$, () => DescribeAlarmsOutput$
+];
+var DescribeAlarmsForMetric$ = [9, n0, _DAFM,
+    0, () => DescribeAlarmsForMetricInput$, () => DescribeAlarmsForMetricOutput$
+];
+var DescribeAnomalyDetectors$ = [9, n0, _DADe,
+    0, () => DescribeAnomalyDetectorsInput$, () => DescribeAnomalyDetectorsOutput$
+];
+var DescribeInsightRules$ = [9, n0, _DIRe,
+    0, () => DescribeInsightRulesInput$, () => DescribeInsightRulesOutput$
+];
+var DisableAlarmActions$ = [9, n0, _DAA,
+    0, () => DisableAlarmActionsInput$, () => __Unit
+];
+var DisableInsightRules$ = [9, n0, _DIRi,
+    0, () => DisableInsightRulesInput$, () => DisableInsightRulesOutput$
+];
+var DisassociateDatasetKmsKey$ = [9, n0, _DDKK,
+    2, () => DisassociateDatasetKmsKeyInput$, () => DisassociateDatasetKmsKeyOutput$
+];
+var EnableAlarmActions$ = [9, n0, _EAA,
+    0, () => EnableAlarmActionsInput$, () => __Unit
+];
+var EnableInsightRules$ = [9, n0, _EIR,
+    0, () => EnableInsightRulesInput$, () => EnableInsightRulesOutput$
+];
+var GetAlarmMuteRule$ = [9, n0, _GAMR,
+    0, () => GetAlarmMuteRuleInput$, () => GetAlarmMuteRuleOutput$
+];
+var GetDashboard$ = [9, n0, _GD,
+    0, () => GetDashboardInput$, () => GetDashboardOutput$
+];
+var GetDataset$ = [9, n0, _GDe,
+    0, () => GetDatasetInput$, () => GetDatasetOutput$
+];
+var GetInsightRuleReport$ = [9, n0, _GIRR,
+    0, () => GetInsightRuleReportInput$, () => GetInsightRuleReportOutput$
+];
+var GetMetricData$ = [9, n0, _GMD,
+    0, () => GetMetricDataInput$, () => GetMetricDataOutput$
+];
+var GetMetricStatistics$ = [9, n0, _GMS,
+    0, () => GetMetricStatisticsInput$, () => GetMetricStatisticsOutput$
+];
+var GetMetricStream$ = [9, n0, _GMSe,
+    0, () => GetMetricStreamInput$, () => GetMetricStreamOutput$
+];
+var GetMetricWidgetImage$ = [9, n0, _GMWI,
+    0, () => GetMetricWidgetImageInput$, () => GetMetricWidgetImageOutput$
+];
+var GetOTelEnrichment$ = [9, n0, _GOTE,
+    0, () => GetOTelEnrichmentInput$, () => GetOTelEnrichmentOutput$
+];
+var ListAlarmMuteRules$ = [9, n0, _LAMR,
+    0, () => ListAlarmMuteRulesInput$, () => ListAlarmMuteRulesOutput$
+];
+var ListDashboards$ = [9, n0, _LD,
+    0, () => ListDashboardsInput$, () => ListDashboardsOutput$
+];
+var ListManagedInsightRules$ = [9, n0, _LMIR,
+    0, () => ListManagedInsightRulesInput$, () => ListManagedInsightRulesOutput$
+];
+var ListMetrics$ = [9, n0, _LMi,
+    0, () => ListMetricsInput$, () => ListMetricsOutput$
+];
+var ListMetricStreams$ = [9, n0, _LMS,
+    0, () => ListMetricStreamsInput$, () => ListMetricStreamsOutput$
+];
+var ListTagsForResource$ = [9, n0, _LTFR,
+    0, () => ListTagsForResourceInput$, () => ListTagsForResourceOutput$
+];
+var PutAlarmMuteRule$ = [9, n0, _PAMR,
+    0, () => PutAlarmMuteRuleInput$, () => __Unit
+];
+var PutAnomalyDetector$ = [9, n0, _PAD,
+    0, () => PutAnomalyDetectorInput$, () => PutAnomalyDetectorOutput$
+];
+var PutCompositeAlarm$ = [9, n0, _PCA,
+    0, () => PutCompositeAlarmInput$, () => __Unit
+];
+var PutDashboard$ = [9, n0, _PD,
+    0, () => PutDashboardInput$, () => PutDashboardOutput$
+];
+var PutInsightRule$ = [9, n0, _PIR,
+    0, () => PutInsightRuleInput$, () => PutInsightRuleOutput$
+];
+var PutLogAlarm$ = [9, n0, _PLA,
+    0, () => PutLogAlarmInput$, () => __Unit
+];
+var PutManagedInsightRules$ = [9, n0, _PMIR,
+    0, () => PutManagedInsightRulesInput$, () => PutManagedInsightRulesOutput$
+];
+var PutMetricAlarm$ = [9, n0, _PMA,
+    0, () => PutMetricAlarmInput$, () => __Unit
+];
+var PutMetricData$ = [9, n0, _PMD,
+    0, () => PutMetricDataInput$, () => __Unit
+];
+var PutMetricStream$ = [9, n0, _PMS,
+    0, () => PutMetricStreamInput$, () => PutMetricStreamOutput$
+];
+var SetAlarmState$ = [9, n0, _SAS,
+    0, () => SetAlarmStateInput$, () => __Unit
+];
+var StartMetricStreams$ = [9, n0, _SMS,
+    0, () => StartMetricStreamsInput$, () => StartMetricStreamsOutput$
+];
+var StartOTelEnrichment$ = [9, n0, _SOTE,
+    0, () => StartOTelEnrichmentInput$, () => StartOTelEnrichmentOutput$
+];
+var StopMetricStreams$ = [9, n0, _SMSt,
+    0, () => StopMetricStreamsInput$, () => StopMetricStreamsOutput$
+];
+var StopOTelEnrichment$ = [9, n0, _SOTEt,
+    0, () => StopOTelEnrichmentInput$, () => StopOTelEnrichmentOutput$
+];
+var TagResource$ = [9, n0, _TR,
+    0, () => TagResourceInput$, () => TagResourceOutput$
+];
+var UntagResource$ = [9, n0, _UR,
+    0, () => UntagResourceInput$, () => UntagResourceOutput$
+];
+
+const getRuntimeConfig$1 = (config) => {
+    return {
+        apiVersion: "2010-08-01",
+        base64Decoder: config?.base64Decoder ?? fromBase64,
+        base64Encoder: config?.base64Encoder ?? toBase64,
+        disableHostPrefix: config?.disableHostPrefix ?? false,
+        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
+        extensions: config?.extensions ?? [],
+        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultCloudWatchHttpAuthSchemeProvider,
+        httpAuthSchemes: config?.httpAuthSchemes ?? [
+            {
+                schemeId: "aws.auth#sigv4",
+                identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
+                signer: new AwsSdkSigV4Signer(),
+            },
+        ],
+        logger: config?.logger ?? new NoOpLogger(),
+        protocol: config?.protocol ?? AwsJson1_0Protocol,
+        protocolSettings: config?.protocolSettings ?? {
+            defaultNamespace: "com.amazonaws.cloudwatch",
+            errorTypeRegistries,
+            xmlNamespace: "http://monitoring.amazonaws.com/doc/2010-08-01/",
+            version: "2010-08-01",
+            serviceTarget: "GraniteServiceVersion20100801",
+            awsQueryCompatible: true,
+        },
+        serviceId: config?.serviceId ?? "CloudWatch",
+        urlParser: config?.urlParser ?? parseUrl,
+        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
+        utf8Encoder: config?.utf8Encoder ?? toUtf8,
+    };
+};
+
+const getRuntimeConfig = (config) => {
+    emitWarningIfUnsupportedVersion(process.version);
+    const defaultsMode = resolveDefaultsModeConfig(config);
+    const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
+    const clientSharedValues = getRuntimeConfig$1(config);
+    emitWarningIfUnsupportedVersion$1(process.version);
+    const loaderConfig = {
+        profile: config?.profile,
+        logger: clientSharedValues.logger,
+    };
+    return {
+        ...clientSharedValues,
+        ...config,
+        runtime: "node",
+        defaultsMode,
+        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
+        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
+        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
+        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
+        disableRequestCompression: config?.disableRequestCompression ?? loadConfig(NODE_DISABLE_REQUEST_COMPRESSION_CONFIG_OPTIONS, config),
+        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
+        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
+        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
+        requestMinCompressionSizeBytes: config?.requestMinCompressionSizeBytes ?? loadConfig(NODE_REQUEST_MIN_COMPRESSION_SIZE_BYTES_CONFIG_OPTIONS, config),
+        retryMode: config?.retryMode ??
+            loadConfig({
+                ...NODE_RETRY_MODE_CONFIG_OPTIONS,
+                default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE,
+            }, config),
+        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
+        streamCollector: config?.streamCollector ?? streamCollector,
+        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
+        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig),
+    };
+};
+
 const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
     const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
     let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
@@ -569,6 +2458,18 @@ class PutInsightRuleCommand extends Command
     .build() {
 }
 
+class PutLogAlarmCommand extends Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("GraniteServiceVersion20100801", "PutLogAlarm", {})
+    .n("CloudWatchClient", "PutLogAlarmCommand")
+    .sc(PutLogAlarm$)
+    .build() {
+}
+
 class PutManagedInsightRulesCommand extends Command
     .classBuilder()
     .ep(commonParams)
@@ -726,7 +2627,7 @@ const paginateListMetrics = createPaginator(CloudWatchClient, ListMetricsCommand
 
 const paginateListMetricStreams = createPaginator(CloudWatchClient, ListMetricStreamsCommand, "NextToken", "NextToken", "MaxResults");
 
-const checkState$2 = async (client, input) => {
+const checkState$3 = async (client, input) => {
     let reason;
     try {
         let result = await client.send(new DescribeAlarmsCommand(input));
@@ -749,15 +2650,15 @@ const checkState$2 = async (client, input) => {
 };
 const waitForAlarmExists = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
 };
 const waitUntilAlarmExists = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$3);
     return checkExceptions(result);
 };
 
-const checkState$1 = async (client, input) => {
+const checkState$2 = async (client, input) => {
     let reason;
     try {
         let result = await client.send(new GetAlarmMuteRuleCommand(input));
@@ -774,15 +2675,15 @@ const checkState$1 = async (client, input) => {
 };
 const waitForAlarmMuteRuleExists = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
 };
 const waitUntilAlarmMuteRuleExists = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$2);
     return checkExceptions(result);
 };
 
-const checkState = async (client, input) => {
+const checkState$1 = async (client, input) => {
     let reason;
     try {
         let result = await client.send(new DescribeAlarmsCommand(input));
@@ -805,9 +2706,40 @@ const checkState = async (client, input) => {
 };
 const waitForCompositeAlarmExists = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
-    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
 };
 const waitUntilCompositeAlarmExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState$1);
+    return checkExceptions(result);
+};
+
+const checkState = async (client, input) => {
+    let reason;
+    try {
+        let result = await client.send(new DescribeAlarmsCommand(input));
+        reason = result;
+        try {
+            const returnComparator = () => {
+                let flat_1 = [].concat(...result.LogAlarms);
+                return (flat_1.length > 0);
+            };
+            if (returnComparator() == true) {
+                return { state: WaiterState.SUCCESS, reason };
+            }
+        }
+        catch (e) { }
+    }
+    catch (exception) {
+        reason = exception;
+    }
+    return { state: WaiterState.RETRY, reason };
+};
+const waitForLogAlarmExists = async (params, input) => {
+    const serviceDefaults = { minDelay: 5, maxDelay: 120 };
+    return createWaiter({ ...serviceDefaults, ...params }, input, checkState);
+};
+const waitUntilLogAlarmExists = async (params, input) => {
     const serviceDefaults = { minDelay: 5, maxDelay: 120 };
     const result = await createWaiter({ ...serviceDefaults, ...params }, input, checkState);
     return checkExceptions(result);
@@ -852,6 +2784,7 @@ const commands = {
     PutCompositeAlarmCommand,
     PutDashboardCommand,
     PutInsightRuleCommand,
+    PutLogAlarmCommand,
     PutManagedInsightRulesCommand,
     PutMetricAlarmCommand,
     PutMetricDataCommand,
@@ -879,6 +2812,7 @@ const paginators = {
 const waiters = {
     waitUntilAlarmExists,
     waitUntilCompositeAlarmExists,
+    waitUntilLogAlarmExists,
     waitUntilAlarmMuteRuleExists,
 };
 class CloudWatch extends CloudWatchClient {
@@ -892,6 +2826,7 @@ const ActionsSuppressedBy = {
 };
 const AlarmType = {
     CompositeAlarm: "CompositeAlarm",
+    LogAlarm: "LogAlarm",
     MetricAlarm: "MetricAlarm",
 };
 const HistoryItemType = {
@@ -994,72 +2929,299 @@ const RecentlyActive = {
 };
 
 exports.ActionsSuppressedBy = ActionsSuppressedBy;
+exports.AlarmContributor$ = AlarmContributor$;
+exports.AlarmHistoryItem$ = AlarmHistoryItem$;
 exports.AlarmMuteRuleStatus = AlarmMuteRuleStatus;
+exports.AlarmMuteRuleSummary$ = AlarmMuteRuleSummary$;
+exports.AlarmPromQLCriteria$ = AlarmPromQLCriteria$;
 exports.AlarmType = AlarmType;
+exports.AnomalyDetector$ = AnomalyDetector$;
+exports.AnomalyDetectorConfiguration$ = AnomalyDetectorConfiguration$;
 exports.AnomalyDetectorStateValue = AnomalyDetectorStateValue;
 exports.AnomalyDetectorType = AnomalyDetectorType;
+exports.AssociateDatasetKmsKey$ = AssociateDatasetKmsKey$;
 exports.AssociateDatasetKmsKeyCommand = AssociateDatasetKmsKeyCommand;
+exports.AssociateDatasetKmsKeyInput$ = AssociateDatasetKmsKeyInput$;
+exports.AssociateDatasetKmsKeyOutput$ = AssociateDatasetKmsKeyOutput$;
 exports.CloudWatch = CloudWatch;
 exports.CloudWatchClient = CloudWatchClient;
+exports.CloudWatchServiceException = CloudWatchServiceException;
+exports.CloudWatchServiceException$ = CloudWatchServiceException$;
 exports.ComparisonOperator = ComparisonOperator;
+exports.CompositeAlarm$ = CompositeAlarm$;
+exports.ConcurrentModificationException = ConcurrentModificationException;
+exports.ConcurrentModificationException$ = ConcurrentModificationException$;
+exports.ConflictException = ConflictException;
+exports.ConflictException$ = ConflictException$;
+exports.DashboardEntry$ = DashboardEntry$;
+exports.DashboardInvalidInputError = DashboardInvalidInputError;
+exports.DashboardInvalidInputError$ = DashboardInvalidInputError$;
+exports.DashboardNotFoundError = DashboardNotFoundError;
+exports.DashboardNotFoundError$ = DashboardNotFoundError$;
+exports.DashboardValidationMessage$ = DashboardValidationMessage$;
+exports.Datapoint$ = Datapoint$;
+exports.DeleteAlarmMuteRule$ = DeleteAlarmMuteRule$;
 exports.DeleteAlarmMuteRuleCommand = DeleteAlarmMuteRuleCommand;
+exports.DeleteAlarmMuteRuleInput$ = DeleteAlarmMuteRuleInput$;
+exports.DeleteAlarms$ = DeleteAlarms$;
 exports.DeleteAlarmsCommand = DeleteAlarmsCommand;
+exports.DeleteAlarmsInput$ = DeleteAlarmsInput$;
+exports.DeleteAnomalyDetector$ = DeleteAnomalyDetector$;
 exports.DeleteAnomalyDetectorCommand = DeleteAnomalyDetectorCommand;
+exports.DeleteAnomalyDetectorInput$ = DeleteAnomalyDetectorInput$;
+exports.DeleteAnomalyDetectorOutput$ = DeleteAnomalyDetectorOutput$;
+exports.DeleteDashboards$ = DeleteDashboards$;
 exports.DeleteDashboardsCommand = DeleteDashboardsCommand;
+exports.DeleteDashboardsInput$ = DeleteDashboardsInput$;
+exports.DeleteDashboardsOutput$ = DeleteDashboardsOutput$;
+exports.DeleteInsightRules$ = DeleteInsightRules$;
 exports.DeleteInsightRulesCommand = DeleteInsightRulesCommand;
+exports.DeleteInsightRulesInput$ = DeleteInsightRulesInput$;
+exports.DeleteInsightRulesOutput$ = DeleteInsightRulesOutput$;
+exports.DeleteMetricStream$ = DeleteMetricStream$;
 exports.DeleteMetricStreamCommand = DeleteMetricStreamCommand;
+exports.DeleteMetricStreamInput$ = DeleteMetricStreamInput$;
+exports.DeleteMetricStreamOutput$ = DeleteMetricStreamOutput$;
+exports.DescribeAlarmContributors$ = DescribeAlarmContributors$;
 exports.DescribeAlarmContributorsCommand = DescribeAlarmContributorsCommand;
+exports.DescribeAlarmContributorsInput$ = DescribeAlarmContributorsInput$;
+exports.DescribeAlarmContributorsOutput$ = DescribeAlarmContributorsOutput$;
+exports.DescribeAlarmHistory$ = DescribeAlarmHistory$;
 exports.DescribeAlarmHistoryCommand = DescribeAlarmHistoryCommand;
+exports.DescribeAlarmHistoryInput$ = DescribeAlarmHistoryInput$;
+exports.DescribeAlarmHistoryOutput$ = DescribeAlarmHistoryOutput$;
+exports.DescribeAlarms$ = DescribeAlarms$;
 exports.DescribeAlarmsCommand = DescribeAlarmsCommand;
+exports.DescribeAlarmsForMetric$ = DescribeAlarmsForMetric$;
 exports.DescribeAlarmsForMetricCommand = DescribeAlarmsForMetricCommand;
+exports.DescribeAlarmsForMetricInput$ = DescribeAlarmsForMetricInput$;
+exports.DescribeAlarmsForMetricOutput$ = DescribeAlarmsForMetricOutput$;
+exports.DescribeAlarmsInput$ = DescribeAlarmsInput$;
+exports.DescribeAlarmsOutput$ = DescribeAlarmsOutput$;
+exports.DescribeAnomalyDetectors$ = DescribeAnomalyDetectors$;
 exports.DescribeAnomalyDetectorsCommand = DescribeAnomalyDetectorsCommand;
+exports.DescribeAnomalyDetectorsInput$ = DescribeAnomalyDetectorsInput$;
+exports.DescribeAnomalyDetectorsOutput$ = DescribeAnomalyDetectorsOutput$;
+exports.DescribeInsightRules$ = DescribeInsightRules$;
 exports.DescribeInsightRulesCommand = DescribeInsightRulesCommand;
+exports.DescribeInsightRulesInput$ = DescribeInsightRulesInput$;
+exports.DescribeInsightRulesOutput$ = DescribeInsightRulesOutput$;
+exports.Dimension$ = Dimension$;
+exports.DimensionFilter$ = DimensionFilter$;
+exports.DisableAlarmActions$ = DisableAlarmActions$;
 exports.DisableAlarmActionsCommand = DisableAlarmActionsCommand;
+exports.DisableAlarmActionsInput$ = DisableAlarmActionsInput$;
+exports.DisableInsightRules$ = DisableInsightRules$;
 exports.DisableInsightRulesCommand = DisableInsightRulesCommand;
+exports.DisableInsightRulesInput$ = DisableInsightRulesInput$;
+exports.DisableInsightRulesOutput$ = DisableInsightRulesOutput$;
+exports.DisassociateDatasetKmsKey$ = DisassociateDatasetKmsKey$;
 exports.DisassociateDatasetKmsKeyCommand = DisassociateDatasetKmsKeyCommand;
+exports.DisassociateDatasetKmsKeyInput$ = DisassociateDatasetKmsKeyInput$;
+exports.DisassociateDatasetKmsKeyOutput$ = DisassociateDatasetKmsKeyOutput$;
+exports.EnableAlarmActions$ = EnableAlarmActions$;
 exports.EnableAlarmActionsCommand = EnableAlarmActionsCommand;
+exports.EnableAlarmActionsInput$ = EnableAlarmActionsInput$;
+exports.EnableInsightRules$ = EnableInsightRules$;
 exports.EnableInsightRulesCommand = EnableInsightRulesCommand;
+exports.EnableInsightRulesInput$ = EnableInsightRulesInput$;
+exports.EnableInsightRulesOutput$ = EnableInsightRulesOutput$;
+exports.Entity$ = Entity$;
+exports.EntityMetricData$ = EntityMetricData$;
+exports.EvaluationCriteria$ = EvaluationCriteria$;
 exports.EvaluationState = EvaluationState;
+exports.GetAlarmMuteRule$ = GetAlarmMuteRule$;
 exports.GetAlarmMuteRuleCommand = GetAlarmMuteRuleCommand;
+exports.GetAlarmMuteRuleInput$ = GetAlarmMuteRuleInput$;
+exports.GetAlarmMuteRuleOutput$ = GetAlarmMuteRuleOutput$;
+exports.GetDashboard$ = GetDashboard$;
 exports.GetDashboardCommand = GetDashboardCommand;
+exports.GetDashboardInput$ = GetDashboardInput$;
+exports.GetDashboardOutput$ = GetDashboardOutput$;
+exports.GetDataset$ = GetDataset$;
 exports.GetDatasetCommand = GetDatasetCommand;
+exports.GetDatasetInput$ = GetDatasetInput$;
+exports.GetDatasetOutput$ = GetDatasetOutput$;
+exports.GetInsightRuleReport$ = GetInsightRuleReport$;
 exports.GetInsightRuleReportCommand = GetInsightRuleReportCommand;
+exports.GetInsightRuleReportInput$ = GetInsightRuleReportInput$;
+exports.GetInsightRuleReportOutput$ = GetInsightRuleReportOutput$;
+exports.GetMetricData$ = GetMetricData$;
 exports.GetMetricDataCommand = GetMetricDataCommand;
+exports.GetMetricDataInput$ = GetMetricDataInput$;
+exports.GetMetricDataOutput$ = GetMetricDataOutput$;
+exports.GetMetricStatistics$ = GetMetricStatistics$;
 exports.GetMetricStatisticsCommand = GetMetricStatisticsCommand;
+exports.GetMetricStatisticsInput$ = GetMetricStatisticsInput$;
+exports.GetMetricStatisticsOutput$ = GetMetricStatisticsOutput$;
+exports.GetMetricStream$ = GetMetricStream$;
 exports.GetMetricStreamCommand = GetMetricStreamCommand;
+exports.GetMetricStreamInput$ = GetMetricStreamInput$;
+exports.GetMetricStreamOutput$ = GetMetricStreamOutput$;
+exports.GetMetricWidgetImage$ = GetMetricWidgetImage$;
 exports.GetMetricWidgetImageCommand = GetMetricWidgetImageCommand;
+exports.GetMetricWidgetImageInput$ = GetMetricWidgetImageInput$;
+exports.GetMetricWidgetImageOutput$ = GetMetricWidgetImageOutput$;
+exports.GetOTelEnrichment$ = GetOTelEnrichment$;
 exports.GetOTelEnrichmentCommand = GetOTelEnrichmentCommand;
+exports.GetOTelEnrichmentInput$ = GetOTelEnrichmentInput$;
+exports.GetOTelEnrichmentOutput$ = GetOTelEnrichmentOutput$;
 exports.HistoryItemType = HistoryItemType;
+exports.InsightRule$ = InsightRule$;
+exports.InsightRuleContributor$ = InsightRuleContributor$;
+exports.InsightRuleContributorDatapoint$ = InsightRuleContributorDatapoint$;
+exports.InsightRuleMetricDatapoint$ = InsightRuleMetricDatapoint$;
+exports.InternalServiceFault = InternalServiceFault;
+exports.InternalServiceFault$ = InternalServiceFault$;
+exports.InvalidFormatFault = InvalidFormatFault;
+exports.InvalidFormatFault$ = InvalidFormatFault$;
+exports.InvalidNextToken = InvalidNextToken;
+exports.InvalidNextToken$ = InvalidNextToken$;
+exports.InvalidParameterCombinationException = InvalidParameterCombinationException;
+exports.InvalidParameterCombinationException$ = InvalidParameterCombinationException$;
+exports.InvalidParameterValueException = InvalidParameterValueException;
+exports.InvalidParameterValueException$ = InvalidParameterValueException$;
+exports.KmsAccessDeniedException = KmsAccessDeniedException;
+exports.KmsAccessDeniedException$ = KmsAccessDeniedException$;
+exports.KmsKeyDisabledException = KmsKeyDisabledException;
+exports.KmsKeyDisabledException$ = KmsKeyDisabledException$;
+exports.KmsKeyNotFoundException = KmsKeyNotFoundException;
+exports.KmsKeyNotFoundException$ = KmsKeyNotFoundException$;
+exports.LabelOptions$ = LabelOptions$;
+exports.LimitExceededException = LimitExceededException;
+exports.LimitExceededException$ = LimitExceededException$;
+exports.LimitExceededFault = LimitExceededFault;
+exports.LimitExceededFault$ = LimitExceededFault$;
+exports.ListAlarmMuteRules$ = ListAlarmMuteRules$;
 exports.ListAlarmMuteRulesCommand = ListAlarmMuteRulesCommand;
+exports.ListAlarmMuteRulesInput$ = ListAlarmMuteRulesInput$;
+exports.ListAlarmMuteRulesOutput$ = ListAlarmMuteRulesOutput$;
+exports.ListDashboards$ = ListDashboards$;
 exports.ListDashboardsCommand = ListDashboardsCommand;
+exports.ListDashboardsInput$ = ListDashboardsInput$;
+exports.ListDashboardsOutput$ = ListDashboardsOutput$;
+exports.ListManagedInsightRules$ = ListManagedInsightRules$;
 exports.ListManagedInsightRulesCommand = ListManagedInsightRulesCommand;
+exports.ListManagedInsightRulesInput$ = ListManagedInsightRulesInput$;
+exports.ListManagedInsightRulesOutput$ = ListManagedInsightRulesOutput$;
+exports.ListMetricStreams$ = ListMetricStreams$;
 exports.ListMetricStreamsCommand = ListMetricStreamsCommand;
+exports.ListMetricStreamsInput$ = ListMetricStreamsInput$;
+exports.ListMetricStreamsOutput$ = ListMetricStreamsOutput$;
+exports.ListMetrics$ = ListMetrics$;
 exports.ListMetricsCommand = ListMetricsCommand;
+exports.ListMetricsInput$ = ListMetricsInput$;
+exports.ListMetricsOutput$ = ListMetricsOutput$;
+exports.ListTagsForResource$ = ListTagsForResource$;
 exports.ListTagsForResourceCommand = ListTagsForResourceCommand;
+exports.ListTagsForResourceInput$ = ListTagsForResourceInput$;
+exports.ListTagsForResourceOutput$ = ListTagsForResourceOutput$;
+exports.LogAlarm$ = LogAlarm$;
+exports.ManagedRule$ = ManagedRule$;
+exports.ManagedRuleDescription$ = ManagedRuleDescription$;
+exports.ManagedRuleState$ = ManagedRuleState$;
+exports.MessageData$ = MessageData$;
+exports.Metric$ = Metric$;
+exports.MetricAlarm$ = MetricAlarm$;
+exports.MetricCharacteristics$ = MetricCharacteristics$;
+exports.MetricDataQuery$ = MetricDataQuery$;
+exports.MetricDataResult$ = MetricDataResult$;
+exports.MetricDatum$ = MetricDatum$;
+exports.MetricMathAnomalyDetector$ = MetricMathAnomalyDetector$;
+exports.MetricStat$ = MetricStat$;
+exports.MetricStreamEntry$ = MetricStreamEntry$;
+exports.MetricStreamFilter$ = MetricStreamFilter$;
 exports.MetricStreamOutputFormat = MetricStreamOutputFormat;
+exports.MetricStreamStatisticsConfiguration$ = MetricStreamStatisticsConfiguration$;
+exports.MetricStreamStatisticsMetric$ = MetricStreamStatisticsMetric$;
+exports.MissingRequiredParameterException = MissingRequiredParameterException;
+exports.MissingRequiredParameterException$ = MissingRequiredParameterException$;
+exports.MuteTargets$ = MuteTargets$;
 exports.OTelEnrichmentStatus = OTelEnrichmentStatus;
+exports.PartialFailure$ = PartialFailure$;
+exports.PutAlarmMuteRule$ = PutAlarmMuteRule$;
 exports.PutAlarmMuteRuleCommand = PutAlarmMuteRuleCommand;
+exports.PutAlarmMuteRuleInput$ = PutAlarmMuteRuleInput$;
+exports.PutAnomalyDetector$ = PutAnomalyDetector$;
 exports.PutAnomalyDetectorCommand = PutAnomalyDetectorCommand;
+exports.PutAnomalyDetectorInput$ = PutAnomalyDetectorInput$;
+exports.PutAnomalyDetectorOutput$ = PutAnomalyDetectorOutput$;
+exports.PutCompositeAlarm$ = PutCompositeAlarm$;
 exports.PutCompositeAlarmCommand = PutCompositeAlarmCommand;
+exports.PutCompositeAlarmInput$ = PutCompositeAlarmInput$;
+exports.PutDashboard$ = PutDashboard$;
 exports.PutDashboardCommand = PutDashboardCommand;
+exports.PutDashboardInput$ = PutDashboardInput$;
+exports.PutDashboardOutput$ = PutDashboardOutput$;
+exports.PutInsightRule$ = PutInsightRule$;
 exports.PutInsightRuleCommand = PutInsightRuleCommand;
+exports.PutInsightRuleInput$ = PutInsightRuleInput$;
+exports.PutInsightRuleOutput$ = PutInsightRuleOutput$;
+exports.PutLogAlarm$ = PutLogAlarm$;
+exports.PutLogAlarmCommand = PutLogAlarmCommand;
+exports.PutLogAlarmInput$ = PutLogAlarmInput$;
+exports.PutManagedInsightRules$ = PutManagedInsightRules$;
 exports.PutManagedInsightRulesCommand = PutManagedInsightRulesCommand;
+exports.PutManagedInsightRulesInput$ = PutManagedInsightRulesInput$;
+exports.PutManagedInsightRulesOutput$ = PutManagedInsightRulesOutput$;
+exports.PutMetricAlarm$ = PutMetricAlarm$;
 exports.PutMetricAlarmCommand = PutMetricAlarmCommand;
+exports.PutMetricAlarmInput$ = PutMetricAlarmInput$;
+exports.PutMetricData$ = PutMetricData$;
 exports.PutMetricDataCommand = PutMetricDataCommand;
+exports.PutMetricDataInput$ = PutMetricDataInput$;
+exports.PutMetricStream$ = PutMetricStream$;
 exports.PutMetricStreamCommand = PutMetricStreamCommand;
+exports.PutMetricStreamInput$ = PutMetricStreamInput$;
+exports.PutMetricStreamOutput$ = PutMetricStreamOutput$;
+exports.Range$ = Range$;
 exports.RecentlyActive = RecentlyActive;
+exports.ResourceConflict = ResourceConflict;
+exports.ResourceConflict$ = ResourceConflict$;
+exports.ResourceNotFound = ResourceNotFound;
+exports.ResourceNotFound$ = ResourceNotFound$;
+exports.ResourceNotFoundException = ResourceNotFoundException;
+exports.ResourceNotFoundException$ = ResourceNotFoundException$;
+exports.Rule$ = Rule$;
 exports.ScanBy = ScanBy;
+exports.Schedule$ = Schedule$;
+exports.ScheduleConfiguration$ = ScheduleConfiguration$;
+exports.ScheduledQueryConfiguration$ = ScheduledQueryConfiguration$;
+exports.SetAlarmState$ = SetAlarmState$;
 exports.SetAlarmStateCommand = SetAlarmStateCommand;
+exports.SetAlarmStateInput$ = SetAlarmStateInput$;
+exports.SingleMetricAnomalyDetector$ = SingleMetricAnomalyDetector$;
 exports.StandardUnit = StandardUnit;
+exports.StartMetricStreams$ = StartMetricStreams$;
 exports.StartMetricStreamsCommand = StartMetricStreamsCommand;
+exports.StartMetricStreamsInput$ = StartMetricStreamsInput$;
+exports.StartMetricStreamsOutput$ = StartMetricStreamsOutput$;
+exports.StartOTelEnrichment$ = StartOTelEnrichment$;
 exports.StartOTelEnrichmentCommand = StartOTelEnrichmentCommand;
+exports.StartOTelEnrichmentInput$ = StartOTelEnrichmentInput$;
+exports.StartOTelEnrichmentOutput$ = StartOTelEnrichmentOutput$;
 exports.StateValue = StateValue;
 exports.Statistic = Statistic;
+exports.StatisticSet$ = StatisticSet$;
 exports.StatusCode = StatusCode;
+exports.StopMetricStreams$ = StopMetricStreams$;
 exports.StopMetricStreamsCommand = StopMetricStreamsCommand;
+exports.StopMetricStreamsInput$ = StopMetricStreamsInput$;
+exports.StopMetricStreamsOutput$ = StopMetricStreamsOutput$;
+exports.StopOTelEnrichment$ = StopOTelEnrichment$;
 exports.StopOTelEnrichmentCommand = StopOTelEnrichmentCommand;
+exports.StopOTelEnrichmentInput$ = StopOTelEnrichmentInput$;
+exports.StopOTelEnrichmentOutput$ = StopOTelEnrichmentOutput$;
+exports.Tag$ = Tag$;
+exports.TagResource$ = TagResource$;
 exports.TagResourceCommand = TagResourceCommand;
+exports.TagResourceInput$ = TagResourceInput$;
+exports.TagResourceOutput$ = TagResourceOutput$;
+exports.UntagResource$ = UntagResource$;
 exports.UntagResourceCommand = UntagResourceCommand;
+exports.UntagResourceInput$ = UntagResourceInput$;
+exports.UntagResourceOutput$ = UntagResourceOutput$;
+exports.errorTypeRegistries = errorTypeRegistries;
 exports.paginateDescribeAlarmHistory = paginateDescribeAlarmHistory;
 exports.paginateDescribeAlarms = paginateDescribeAlarms;
 exports.paginateDescribeAnomalyDetectors = paginateDescribeAnomalyDetectors;
@@ -1073,6 +3235,8 @@ exports.paginateListMetrics = paginateListMetrics;
 exports.waitForAlarmExists = waitForAlarmExists;
 exports.waitForAlarmMuteRuleExists = waitForAlarmMuteRuleExists;
 exports.waitForCompositeAlarmExists = waitForCompositeAlarmExists;
+exports.waitForLogAlarmExists = waitForLogAlarmExists;
 exports.waitUntilAlarmExists = waitUntilAlarmExists;
 exports.waitUntilAlarmMuteRuleExists = waitUntilAlarmMuteRuleExists;
 exports.waitUntilCompositeAlarmExists = waitUntilCompositeAlarmExists;
+exports.waitUntilLogAlarmExists = waitUntilLogAlarmExists;